Home > Article > Backend Development > A Quick Guide to the Python threading Module with Examples
The threading module in Python provides a high-level interface to create and manage threads, enabling you to run code concurrently. This can be especially useful for tasks that can be executed in parallel, such as I/O-bound operations. Below is a list of commonly used methods and functions in the threading module, with brief examples.
The Thread class is the heart of the threading module. You can create and start new threads using this class.
import threading def print_numbers(): for i in range(5): print(i) t = threading.Thread(target=print_numbers) t.start() # Starts a new thread t.join() # Waits for the thread to finish
Starts the thread's activity.
t = threading.Thread(target=print_numbers) t.start() # Runs the target function in a separate thread
Blocks the calling thread until the thread whose join() method is called terminates. Optionally, you can specify a timeout.
t = threading.Thread(target=print_numbers) t.start() t.join(2) # Waits up to 2 seconds for the thread to finish
Returns True if the thread is still running.
t = threading.Thread(target=print_numbers) t.start() print(t.is_alive()) # True if the thread is still running
Returns the current Thread object, representing the calling thread.
import threading def print_current_thread(): print(threading.current_thread()) t = threading.Thread(target=print_current_thread) t.start() # Prints the current thread info
Returns a list of all Thread objects currently alive.
t1 = threading.Thread(target=print_numbers) t2 = threading.Thread(target=print_numbers) t1.start() t2.start() print(threading.enumerate()) # Lists all active threads
Returns the number of Thread objects currently alive.
print(threading.active_count()) # Returns the number of active threads
A Lock object is a primitive lock that is used to prevent race conditions. You can use it to ensure only one thread accesses a shared resource at a time.
lock = threading.Lock() def thread_safe_function(): with lock: # Acquires the lock # Critical section print("Thread-safe code") t = threading.Thread(target=thread_safe_function) t.start()
A reentrant lock allows a thread to acquire() the lock multiple times without blocking itself.
lock = threading.RLock() def reentrant_function(): with lock: with lock: # Same thread can acquire the lock again print("Reentrant lock example") t = threading.Thread(target=reentrant_function) t.start()
A Condition object allows threads to wait for some condition to be met.
condition = threading.Condition() def thread_wait(): with condition: condition.wait() # Wait for the condition print("Condition met") def thread_notify(): with condition: condition.notify() # Notify the waiting thread t1 = threading.Thread(target=thread_wait) t2 = threading.Thread(target=thread_notify) t1.start() t2.start()
An Event object is used to signal between threads. A thread can wait for an event to be set, and another thread can set the event.
event = threading.Event() def wait_for_event(): event.wait() # Wait until the event is set print("Event has been set") t = threading.Thread(target=wait_for_event) t.start() event.set() # Set the event to allow the thread to continue
A Semaphore object allows you to limit the number of threads that can access a resource simultaneously.
semaphore = threading.Semaphore(2) # Only 2 threads can access the resource at once def access_resource(): with semaphore: print("Resource accessed") t1 = threading.Thread(target=access_resource) t2 = threading.Thread(target=access_resource) t3 = threading.Thread(target=access_resource) t1.start() t2.start() t3.start()
A Timer thread executes a function after a specified interval.
def delayed_function(): print("Executed after delay") timer = threading.Timer(3, delayed_function) timer.start() # Executes `delayed_function` after 3 seconds
Daemon threads run in the background and exit automatically when the main program exits. You can make a thread a daemon by calling setDaemon(True) or passing daemon=True to the Thread constructor.
t = threading.Thread(target=print_numbers, daemon=True) t.start() # Daemon thread will exit when the main program ends
The threading module is a powerful tool for handling concurrency in Python. It provides multiple classes and methods to create and control threads, making it easy to execute code in parallel. From using basic Thread objects to managing synchronization with Lock and Semaphore, this module is essential for writing concurrent Python programs.
The above is the detailed content of A Quick Guide to the Python threading Module with Examples. For more information, please follow other related articles on the PHP Chinese website!