This module constructs higher-level threading interfaces on top
of the lower level thread module.
This module is safe for use with "from
threading import *". It defines the following functions and
objects:
-
activeCount ()
- Return the number of currently active
Thread objects. The returned count is equal to the length of
the list returned by enumerate(). A
function that returns the number of currently active threads.
-
Condition ()
- A factory function that returns a new condition variable
object. A condition variable allows one or more threads to wait
until they are notified by another thread.
-
currentThread ()
- Return the current Thread object,
corresponding to the caller's thread of control. If the caller's
thread of control was not created through the
threading module, a dummy thread object with limited
functionality is returned.
-
enumerate ()
- Return a list of all currently active
Thread objects. The list includes daemonic threads, dummy
thread objects created by
currentThread(), and the main thread. It excludes terminated
threads and threads that have not yet been started.
- Event
()
- A factory function that returns a new event object. An event
manages a flag that can be set to true with the
set() method and reset to false with the
clear() method. The wait() method
blocks until the flag is true.
- Lock
()
- A factory function that returns a new primitive lock object.
Once a thread has acquired it, subsequent attempts to acquire it
block, until it is released; any thread may release it.
- RLock
()
- A factory function that returns a new reentrant lock object. A
reentrant lock must be released by the thread that acquired it.
Once a thread has acquired a reentrant lock, the same thread may
acquire it again without blocking; the thread must release it once
for each time it has acquired it.
-
Semaphore ()
- A factory function that returns a new semaphore object. A
semaphore manages a counter representing the number of release() calls minus the number of acquire() calls, plus an initial value. The acquire() method blocks if necessary until it
can return without making the counter negative.
- Thread
()
- A class that represents a thread of control. This class can be
safely subclassed in a limited fashion.
Detailed interfaces for the objects are documented below.
The design of this module is loosely based on Java's threading
model. However, where Java makes locks and condition variables
basic behavior of every object, they are separate objects in
Python. Python's Thread class supports a
subset of the behavior of Java's Thread class; currently, there are
no priorities, no thread groups, and threads cannot be destroyed,
stopped, suspended, resumed, or interrupted. The static methods of
Java's Thread class, when implemented, are mapped to module-level
functions.
All of the methods described below are executed atomically.
Send comments to
python-docs@python.org.
