How to use the threading module to create and manage threads in Python 3.x

How to use the threading module to create and manage threads in Python 3.x

Introduction:
With the powerful performance of computers, multi-threading has become a common method of parallel processing. In Python's standard library, there is a convenient module - threading. This article will introduce how to use the threading module in Python 3.x to create and manage threads, and illustrate it with code examples.

1. What is a thread?
A thread is an independent process executed in a single process. It is the smallest unit for scheduling by the operating system. A process can contain multiple threads, which share the resources of the process but also have their own states and execution paths. Multi-threading can execute multiple tasks at the same time and improve the efficiency of the program.

2. Why use threads?
In some cases, multiple tasks need to be performed at the same time, such as downloading multiple files at the same time, processing large amounts of data at the same time, etc. Threads can be used to execute these tasks in parallel and improve the efficiency of the program. In addition, threads can also be used to process some operations that require real-time response, such as updating the UI interface, processing user input, etc.

3. Use the threading module to create and manage threads
In Python, you can easily create and manage threads using the threading module. The following are some commonly used operations:

1. Creating a thread
   You can create a thread by inheriting the Thread class or passing in the target parameter. Inheriting the Thread class requires overriding the run method and starting the thread by calling the start method. When passing in the target parameter, you need to define a function as the execution body of the thread.

The sample code is as follows:

import threading

# 继承Thread类
class MyThread(threading.Thread):
    def run(self):
        # 线程的执行体
        print("In MyThread")

# 定义线程的执行体
def thread_func():
    print("In thread_func")

# 创建线程
t1 = MyThread()
t2 = threading.Thread(target=thread_func)

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

2. Set thread attributes
   You can use the setDaemon method to set the thread as a daemon thread. When the main thread ends, the daemon thread will follow Finish. Use the setName method and getName method to set and get the name of the thread.

The sample code is as follows:

import threading
import time

def thread_func():
    print("In thread_func")
    time.sleep(2)
    print("Thread finished")

# 创建线程
t = threading.Thread(target=thread_func)
t.setDaemon(True)
t.setName("DemoThread")

# 启动线程
t.start()

# 主线程继续执行
print("Main thread")

3. Thread synchronization
   There may be shared resources between threads. In order to avoid race conditions (Race Condition) and data inconsistency Question, you can use lock to synchronize thread operations.

The sample code is as follows:

import threading

# 共享资源
counter = 0
lock = threading.Lock()

# 线程的执行体
def thread_func():
    global counter
    for _ in range(100000):
        # 获取锁
        lock.acquire()
        counter += 1
        # 释放锁
        lock.release()

# 创建线程
t1 = threading.Thread(target=thread_func)
t2 = threading.Thread(target=thread_func)

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

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

# 打印结果
print("counter =", counter)

4. Summary
Using the threading module can easily create and manage threads and achieve parallel processing of multi-tasks. When writing multi-threaded programs, you need to pay attention to synchronization issues between threads to avoid race conditions and data inconsistencies. I hope this article was helpful in creating and managing threads using the threading module in Python 3.x.

The above is the detailed content of How to use the threading module to create and manage threads in Python 3.x. For more information, please follow other related articles on the PHP Chinese website!