threading — Thread-based parallelism — Python 3.11.17 documentation
Navigation index modules | next | previous | Python » 3.11.17 Documentation » The Python Standard Library » Concurrent Execution » threading — Thread-based parallelism | Theme | threading — Thread-based parallelism ¶ Source code: Lib/threading.py This module constructs higher-level threading interfaces on top of the lower level _thread module. Changed in version 3.7: This module used to be optional, it is now always available.
See also concurrent.futures.ThreadPoolExecutor offers a higher level interface to push tasks to a background thread without blocking execution of the calling thread, while still being able to retrieve their results when needed. queue provides a thread-safe interface for exchanging data between running threads. asyncio offers an alternative approach to achieving task level concurrency without requiring the use of multiple operating system threads.
Note In the Python 2.x series, this module contained camelCase names for some methods and functions. These are deprecated as of Python 3.10, but they are still supported for compatibility with Python 2.5 and lower. CPython implementation detail: In CPython, due to the Global Interpreter Lock , only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation).
If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing or concurrent.futures.ProcessPoolExecutor . However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously. Availability : not Emscripten, not WASI. This module does not work or is not available on WebAssembly platforms wasm32-emscripten and wasm32-wasi .
See WebAssembly platforms for more information. This module defines the following functions: threading. active_count ( ) ¶ Return the number of Thread objects currently alive. The returned count is equal to the length of the list returned by enumerate() . The function activeCount is a deprecated alias for this function. threading. current_thread ( ) ¶ 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. The function currentThread is a deprecated alias for this function. threading. excepthook ( args , / ) ¶ Handle uncaught exception raised by Thread.run() . The args argument has the following attributes: exc_type : Exception type. exc_value : Exception value, can be None . exc_traceback : Exception traceback, can be None . thread : Thread which raised the exception, can be None .
If exc_type is SystemExit , the exception is silently ignored. Otherwise, the exception is printed out on sys.stderr . If this function raises an exception, sys.excepthook() is called to handle it. threading.excepthook() can be overridden to control how uncaught exceptions raised by Thread.run() are handled. Storing exc_value using a custom hook can create a reference cycle. It should be cleared explicitly to break the reference cycle when the exception is no longer needed.
Storing thread using a custom hook can resurrect it if it is set to an object which is being finalized. Avoid storing thread after the custom hook completes to avoid resurrecting objects. See also sys.excepthook() handles uncaught exceptions. New in version 3.8. threading. __excepthook__ ¶ Holds the original value of threading.excepthook() . It is saved so that the original value can be restored in case they happen to get replaced with broken or alternative objects.
New in version 3.10. threading. get_ident ( ) ¶ Return the ‘thread identifier’ of the current thread. This is a nonzero integer. Its value has no direct meaning; it is intended as a magic cookie to be used e.g. to index a dictionary of thread-specific data. Thread identifiers may be recycled when a thread exits and another thread is created. New in version 3.3. threading. get_native_id ( ) ¶ Return the native integral Thread ID of the current thread assigned by the kernel.
This is a non-negative integer. Its value may be used to uniquely identify this particular thread system-wide (until the thread terminates, after which the value may be recycled by the OS). Availability : Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX. New in version 3.8. threading. enumerate ( ) ¶ Return a list of all Thread objects currently active. The list includes daemonic threads and dummy thread objects created by current_thread() .
It excludes terminated threads and threads that have not yet been started. However, the main thread is always part of the result, even when terminated. threading. main_thread ( ) ¶ Return the main Thread object. In normal conditions, the main thread is the thread from which the Python interpreter was started. New in version 3.4. threading. settrace ( func ) ¶ Set a trace function for all threads started from the threading module.
The func will be passed to sys.settrace() for each thread, before its run() method is called. threading. gettrace ( ) ¶ Get the trace function as set by settrace() . New in version 3.10. threading. setprofile ( func ) ¶ Set a profile function for all threads started from the threading module. The func will be passed to sys.setprofile() for each thread, before its run() method is called. threading. getprofile ( ) ¶ Get the profiler function as set by setprofile() .
New in version 3.10. threading. stack_size ( [ size ] ) ¶ Return the thread stack size used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 32,768 (32 KiB). If size is not specified, 0 is used. If changing the thread stack size is unsupported, a RuntimeError is raised.
If the specified stack size is invalid, a ValueError is raised and the stack size is unmodified. 32 KiB is currently the minimum supported stack size value to guarantee sufficient stack space for the interpreter itself. Note that some platforms may have particular restrictions on values for the stack size, such as requiring a minimum stack size > 32 KiB or requiring allocation in multiples of the system memory page size - platform documentation should be referred to for more information (4 KiB pages are common; using multiples of 4096 for the stack size is the suggested approach in the absence of more specific information).
Availability : Windows, pthreads. Unix platforms with POSIX threads support. This module also defines the following constant: threading. TIMEOUT_MAX ¶ The maximum value allowed for the timeout parameter of blocking functions ( Lock.acquire() , RLock.acquire() , Condition.wait() , etc.). Specifying a timeout greater than this value will raise an OverflowError . New in version 3.2. This module defines a number of classes, which are detailed in the sections 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. Thread-Local Data ¶ Thread-local data is data whose values are thread specific. To manage thread-local data, just create an instance of local (or a subclass) and store attributes on it: mydata = threading . local () mydata . x = 1 The instance’s values will be different for separate threads. class threading. local ¶ A class that represents thread-local data.
The rest of this page is on the live site.