Gevent

Warnings

• gotcha Monkey patching (`gevent.monkey.patch_all()`) must be performed as early as possible in your application's lifecycle, ideally as the very first lines of code in your main module, on the main thread, and before any other modules that might use blocking I/O are imported. Delaying this can lead to unpredictable behavior, conflicts, or errors because parts of the standard library might already be imported in their unpatched, blocking versions.
  Fix: Place `from gevent import monkey; monkey.patch_all()` at the absolute top of your main script or entry point, even before other imports. If using a framework like Gunicorn with `gevent` workers, check its documentation as it might handle patching for you.
• gotcha Using Python's `multiprocessing` module in conjunction with `gevent.monkey.patch_all()` (especially if `socket` is patched, which is the default) can be highly problematic and lead to subtle, hard-to-debug issues, as `multiprocessing` relies on standard (unpatched) OS-level threading/socket behavior.
  Fix: If you need multiprocessing with Gevent, consider using `gipc` (gevent-cooperative child processes and IPC), which is designed to integrate safely with Gevent. Alternatively, explicitly disable `socket` patching if `multiprocessing` is used.
• gotcha Gevent is designed to make I/O-bound operations (like network requests, disk I/O) concurrent by yielding control during blocking calls. It does not provide true parallelism for CPU-bound tasks within a single process due to Python's Global Interpreter Lock (GIL). Using Gevent for CPU-intensive workloads will not improve performance and can actually make your application slower by adding cooperative multitasking overhead.
  Fix: For CPU-bound tasks, use `multiprocessing` or a task queue system with multiple worker processes. Only apply Gevent where your application's bottleneck is I/O waiting time.
• deprecated The magic proxy object `gevent.signal`, which served as both a deprecated alias for `gevent.signal_handler` and the `gevent.signal` module, was removed because it caused confusion for users and static analysis tools.
  Fix: Use `gevent.signal_handler` directly when handling signals.
• breaking In Gevent v25, changes in import ordering might break projects relying on `gevent.monkey` if `concurrent.futures` is imported before user-defined code. This is because `concurrent.futures` can hold references to unpatched threading threads that cannot be patched by Gevent later.
  Fix: Ensure `gevent.monkey.patch_all()` is called at the absolute earliest point in your application, before any other imports, especially those that might implicitly or explicitly import `concurrent.futures` or related threading modules. You may need to restructure imports if this issue arises.
• gotcha Gevent does not support CPython's experimental free-threading mode (introduced in Python 3.13 and 3.14). If used in such an interpreter, Gevent (and its underlying `greenlet` library) will cause the GIL to be re-enabled. Attempting to use Gevent in free-threading mode is not recommended and may lead to resource leaks.
  Fix: Avoid using Gevent with CPython interpreters configured for experimental free-threading mode. Ensure your environment uses a standard CPython build if you rely on Gevent.

Install

• pip install gevent Install Gevent

Imports

• monkey

  from gevent import monkey; monkey.patch_all()

  While `import gevent.monkey` works, `from gevent import monkey` is a common idiom for brevity, especially before calling `patch_all()`.
• spawn

  import gevent; g = gevent.spawn(my_function, arg1, arg2)

  Schedules a function to run as a greenlet.
• joinall

  import gevent; gevent.joinall([g1, g2])

  Waits for multiple greenlets to complete.
• sleep

  import gevent; gevent.sleep(0)

  Cooperatively yields control to other greenlets for a specified duration or immediately if 0.
• Greenlet

  from gevent import Greenlet

  Direct access to the Greenlet class for advanced usage like subclassing.
• local

  from gevent.local import local

  Provides greenlet-local storage, similar to threading.local.

Quickstart

This quickstart demonstrates the core usage of Gevent: first, it applies monkey patching to make standard library functions cooperative. Then, it spawns multiple greenlets to perform I/O-bound tasks (fetching URLs) concurrently, and finally, it waits for all of them to complete.

from gevent import monkey; monkey.patch_all()
import gevent
import requests

def fetch_url(url):
    print(f"Fetching {url}...")
    try:
        response = requests.get(url, timeout=5) # requests uses patched socket
        print(f"Finished fetching {url}, status: {response.status_code}")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error fetching {url}: {e}")
        return 0

urls = [
    "https://www.google.com",
    "https://www.github.com",
    "https://www.python.org"
]

# Spawn greenlets for each URL fetch
greenlets = [gevent.spawn(fetch_url, url) for url in urls]

# Wait for all greenlets to complete
gevent.joinall(greenlets)

total_bytes = sum(g.value for g in greenlets if g.successful())
print(f"Total bytes fetched: {total_bytes}")