How to use the threading module for multi-thread management in Python 2.x

How to use the threading module for multi-thread management in Python 2.x

In Python, multi-threading can be used to perform multiple tasks simultaneously in the same program, thereby improving the running efficiency of the program. The threading module is a module provided by Python for managing threads. By using the threading module, we can easily create, control and manage multiple threads.

This article will introduce how to use the threading module for multi-thread management in Python 2.x, and give relevant code examples. First, we need to import the threading module:

import threading

Next, we can use the Thread class of the threading module to create a new thread. There are two ways to create a thread: one is to directly instantiate the Thread class, and the other is to inherit the Thread class and override the run() method. These two methods are introduced below.

Method 1: Directly instantiate the Thread class

# 创建线程的函数
def worker():
    print('Worker')

# 创建线程实例
t = threading.Thread(target=worker)

# 启动线程
t.start()

# 等待线程结束
t.join()

In the above example, we first define a worker() function, which will be used as a task for the thread to execute. Then, we instantiated a Thread object t and specified the thread's execution function as worker() through the target parameter. Next, we call the t.start() method to start the thread, and the thread will start executing the tasks in the worker() function.

Method 2: Inherit the Thread class and rewrite the run() method

# 创建继承自 Thread 的子类
class MyThread(threading.Thread):
    def run(self):
        print('Worker')

# 创建线程实例
t = MyThread()

# 启动线程
t.start()

# 等待线程结束
t.join()

In this method, we need to create a subclass that inherits from the Thread class and rewrite it in the subclass. Write run() method. The execution tasks of the thread are defined in the run() method. Then, we instantiate a subclass object t and use this object to start the thread. Same as method 1, we can also wait for the execution of the thread to end through t.join().

When using the threading module for multi-thread management, we often encounter situations where data communication needs to be carried out between threads. In the threading module, some synchronization primitives are provided to help us realize data sharing and communication between threads.

A commonly used synchronization primitive is a mutex (Mutex). Mutex locks can be used to ensure that only one thread can access a shared resource at the same time. In the threading module, we can use the Lock class to create a mutex.

# 创建互斥锁
lock = threading.Lock()

# 定义一个共享数据
shared_data = []

# 创建线程的函数
def worker():
    # 加锁
    lock.acquire()
    try:
        # 对共享数据进行操作
        shared_data.append('Hello')
        shared_data.append('World')
        print(shared_data)
    finally:
        # 释放锁
        lock.release()

# 创建线程实例
t1 = threading.Thread(target=worker)
t2 = threading.Thread(target=worker)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

In the above example, we first created a mutex lock. Then, in the worker() function, we first call the lock.acquire() method to acquire the lock, then operate on the shared data shared_data, and finally call the lock.release() method to release the lock. Through the use of mutex locks, we can ensure that only one thread can operate shared_data at the same time and avoid data competition problems caused by multiple threads accessing shared data at the same time.

In addition to mutex locks, the threading module also provides other synchronization primitives, such as semaphores (Semaphore), condition variables (Condition), events (Event), etc. By properly applying these synchronization primitives, we can achieve complex inter-thread communication and coordination.

To summarize, it is very simple to use the threading module for multi-thread management in Python 2.x. We can use the Thread class of the threading module to create a thread and define the execution tasks of the thread in two ways (directly instantiating the Thread class and inheriting the Thread class). At the same time, we can also realize data sharing and communication between threads through synchronization primitives such as mutex locks. Mastering this knowledge, we can flexibly use multi-threading to improve the running efficiency of the program.

Reference:

1. Python official documentation threading module: https://docs.python.org/2/library/threading.html

The above is the detailed content of How to use the threading module for multi-thread management in Python 2.x. For more information, please follow other related articles on the PHP Chinese website!