0
# Core Greenlets
1
2
Fundamental greenlet operations that form the foundation of gevent's cooperative concurrency model. Greenlets are lightweight cooperative threads that yield control during I/O operations, enabling high concurrency without traditional threading complexity.
3
4
## Capabilities
5
6
### Greenlet Creation and Management
7
8
Create and manage individual greenlets for concurrent execution of functions.
9
10
```python { .api }
11
def spawn(function, *args, **kwargs) -> Greenlet:
12
"""
13
Spawn a new greenlet to run function with given arguments.
14
15
Parameters:
16
- function: callable to execute in greenlet
17
- *args: positional arguments for function
18
- **kwargs: keyword arguments for function
19
20
Returns:
21
Greenlet object that will execute the function
22
"""
23
24
def spawn_later(seconds, function, *args, **kwargs) -> Greenlet:
25
"""
26
Spawn a greenlet after a delay.
27
28
Parameters:
29
- seconds: float, delay in seconds before starting
30
- function: callable to execute
31
- *args: positional arguments for function
32
- **kwargs: keyword arguments for function
33
34
Returns:
35
Greenlet object scheduled to start after delay
36
"""
37
38
def spawn_raw(function, *args, **kwargs) -> Greenlet:
39
"""
40
Spawn a greenlet without any of the spawn wrapper functionality.
41
42
Parameters:
43
- function: callable to execute
44
- *args: positional arguments
45
- **kwargs: keyword arguments
46
47
Returns:
48
Raw greenlet object
49
"""
50
```
51
52
### Greenlet Coordination
53
54
Coordinate multiple greenlets for synchronization and resource management.
55
56
```python { .api }
57
def joinall(greenlets, timeout=None, raise_error=False):
58
"""
59
Wait for all greenlets to finish.
60
61
Parameters:
62
- greenlets: iterable of Greenlet objects
63
- timeout: float, maximum time to wait in seconds
64
- raise_error: bool, whether to raise exception if any greenlet failed
65
66
Returns:
67
None
68
"""
69
70
def killall(greenlets, exception=GreenletExit, block=True, timeout=None):
71
"""
72
Kill all greenlets in the list.
73
74
Parameters:
75
- greenlets: iterable of Greenlet objects
76
- exception: exception to raise in greenlets
77
- block: bool, whether to wait for greenlets to die
78
- timeout: float, maximum time to wait if blocking
79
80
Returns:
81
None
82
"""
83
84
def kill(greenlet, exception=GreenletExit, block=True, timeout=None):
85
"""
86
Kill a single greenlet.
87
88
Parameters:
89
- greenlet: Greenlet object to kill
90
- exception: exception to raise in greenlet
91
- block: bool, whether to wait for greenlet to die
92
- timeout: float, maximum time to wait if blocking
93
94
Returns:
95
None
96
"""
97
```
98
99
### Control Flow
100
101
Control execution flow and timing in cooperative environment.
102
103
```python { .api }
104
def sleep(seconds=0):
105
"""
106
Suspend current greenlet for at least the given time.
107
108
Parameters:
109
- seconds: float, time to sleep in seconds (0 yields to other greenlets)
110
111
Returns:
112
None
113
"""
114
115
def idle(priority=0):
116
"""
117
Block until the event loop is idle.
118
119
Parameters:
120
- priority: int, priority level for the idle callback
121
122
Returns:
123
None
124
"""
125
126
def get_hub() -> Hub:
127
"""
128
Get the hub for the current thread.
129
130
Returns:
131
Hub object for current thread
132
"""
133
134
def getcurrent() -> Greenlet:
135
"""
136
Get the currently executing greenlet.
137
138
Returns:
139
Current Greenlet object
140
"""
141
```
142
143
### Hub Management
144
145
Manage the central event loop coordinator.
146
147
```python { .api }
148
def reinit():
149
"""
150
Reinitialize gevent after forking.
151
152
Returns:
153
None
154
"""
155
156
def getswitchinterval() -> float:
157
"""
158
Get the greenlet switch interval.
159
160
Returns:
161
Current switch interval in seconds
162
"""
163
164
def setswitchinterval(interval):
165
"""
166
Set the greenlet switch interval.
167
168
Parameters:
169
- interval: float, switch interval in seconds
170
171
Returns:
172
None
173
"""
174
```
175
176
### Signal Handling
177
178
Handle Unix signals cooperatively.
179
180
```python { .api }
181
def signal_handler(signalnum, handler, *args, **kwargs):
182
"""
183
Install a signal handler.
184
185
Parameters:
186
- signalnum: int, signal number
187
- handler: callable, handler function
188
- *args: arguments for handler
189
- **kwargs: keyword arguments for handler
190
191
Returns:
192
signal object
193
"""
194
```
195
196
## Usage Examples
197
198
### Basic Greenlet Usage
199
200
```python
201
import gevent
202
203
def worker(name, delay):
204
print(f"Worker {name} starting")
205
gevent.sleep(delay)
206
print(f"Worker {name} finished")
207
return f"Result from {name}"
208
209
# Spawn multiple workers
210
workers = [
211
gevent.spawn(worker, 'A', 1),
212
gevent.spawn(worker, 'B', 2),
213
gevent.spawn(worker, 'C', 0.5)
214
]
215
216
# Wait for all to complete
217
gevent.joinall(workers)
218
219
# Get results
220
for w in workers:
221
if w.successful():
222
print(f"Result: {w.value}")
223
```
224
225
### Delayed Execution
226
227
```python
228
import gevent
229
230
def delayed_task():
231
print("Task executed after delay")
232
233
# Start task after 2 seconds
234
greenlet = gevent.spawn_later(2, delayed_task)
235
greenlet.join()
236
```
237
238
### Error Handling
239
240
```python
241
import gevent
242
243
def failing_task():
244
raise ValueError("Something went wrong")
245
246
def safe_task():
247
return "Success"
248
249
greenlets = [
250
gevent.spawn(failing_task),
251
gevent.spawn(safe_task)
252
]
253
254
gevent.joinall(greenlets)
255
256
for g in greenlets:
257
if g.successful():
258
print(f"Success: {g.value}")
259
else:
260
print(f"Failed: {g.exception}")
261
```