Hide navigation sidebar
Hide table of contents sidebar
Skip to content
Back to top
Toggle table of contents sidebar

# `gevent.thread` – Implementation of the standard `thread` module that spawns greenlets

Implementation of the standard `thread` module that spawns greenlets.

Note

This module is a helper for `gevent.monkey` and is not intended to be used directly. For spawning greenlets in your applications, prefer higher level constructs like `gevent.Greenlet` class or `gevent.spawn()`.

error

  alias of `RuntimeError`

class LockType

  Bases: `_AtomicBoundedSemaphore`

  The basic lock type.

  Changed in version 24.10.1: Subclassing this object is no longer allowed. This matches the Python 3 API.

  Changed in version 24.10.1: No longer accepts arguments to pass to the super class. If you want a semaphore with a different count, use a semaphore class directly. This matches the Lock API of Python 3

  acquire(blocking=True, timeout=None) → bool

    Acquire the semaphore.

    Note

    If this semaphore was initialized with a value of 0, this method will block forever (unless a timeout is given or blocking is set to false).

    Parameters:

      - blocking (bool) – If True (the default), this function will block until the semaphore is acquired.

      - timeout (float) – If given, and blocking is true, specifies the maximum amount of seconds this method will block.

    Returns:

      A `bool` indicating whether the semaphore was acquired. If `blocking` is True and `timeout` is None (the default), then (so long as this semaphore was initialized with a size greater than 0) this will always return True. If a timeout was given, and it expired before the semaphore was acquired, False will be returned. (Note that this can still raise a `Timeout` exception, if some other caller had already started a timer.)

allocate_lock

  alias of `LockType`

lock

  alias of `LockType`

allocate()

  An obsolete synonym of allocate_lock().

daemon_threads_allowed()

  Return True if daemon threads are allowed in the current interpreter, and False otherwise.

exit_thread()

  An obsolete synonym of exit().

get_native_id()

  Return a non-negative integer identifying the thread as reported by the OS (kernel). This may be used to uniquely identify a particular thread within a system.

interrupt_main(signum=Signals.SIGINT, /)

  Simulate the arrival of the given signal in the main thread, where the corresponding signal handler will be executed. If signum is omitted, SIGINT is assumed. A subthread can use this function to interrupt the main thread.

  Note: the default signal handler for SIGINT raises `KeyboardInterrupt`.

start_joinable_thread(function, handle=None, daemon=True)

  For internal use only: start a new thread.

  Like start_new_thread(), this starts a new thread calling the given function. Unlike start_new_thread(), this returns a handle object with methods to join or detach the given thread. This function is not for third-party code, please use the `threading` module instead. During finalization the runtime will not wait for the thread to exit if daemon is True. If handle is provided it must be a newly created thread._ThreadHandle instance.

start_new(function, args, kwargs={}, /)

  An obsolete synonym of start_new_thread().