Python 中如何使用 threading 模块实现线程编程？
在多任务编程中，线程是一种非常有效的手段，可以让多个任务同时执行，从而提高程序的执行效率。Python 提供了 threading 模块，用于创建和管理线程。在这文中，将深入探讨如何使用 threading 模块来创建线程，并介绍如何实现线程同步，以确保多线程程序的正确性和效率。
一、Python 中的线程基本概念
线程是程序中的独立执行单元，可以并发执行代码。Python 中的线程由 threading 模块提供支持。多个线程可以共享同一个进程的内存空间，这意味着它们可以同时访问共享数据。
线程可以分为两类：
- 主线程：程序开始时默认创建的线程，通常用于执行程序的主逻辑。
- 子线程：由主线程创建的其他线程，用于并发执行任务。
在 Python 中，线程的执行是由操作系统调度的，多个线程之间共享 CPU 时间片。Python 通过提供 threading 模块，可以方便地创建、控制和同步线程。
二、如何使用 threading 模块创建线程
Python 中创建线程的最常见方式有两种：通过继承 threading.Thread 类，或直接使用 threading.Thread 类创建实例并传入执行目标函数。
1. 创建线程——使用 threading.Thread 创建线程
使用 threading.Thread 创建线程时，可以通过 target 参数指定线程要执行的函数。每个线程会在创建后自动启动，并执行指定的任务。
示例：创建简单线程
import threading
# 线程执行的任务
def print_numbers():
for i in range(5):
print(i)
# 创建线程
thread = threading.Thread(target=print_numbers)
# 启动线程
thread.start()
# 等待线程执行完毕
thread.join()
print("Thread execution completed")
在上述代码中：
target=print_numbers指定了线程启动时要执行的函数。thread.start()启动线程，线程开始执行print_numbers()函数。thread.join()会阻塞主线程，直到当前线程执行完毕。
2. 通过继承 threading.Thread 类创建线程
除了直接创建 Thread 实例并传递目标函数外，还可以通过继承 threading.Thread 类来自定义线程行为。
示例：通过继承 Thread 创建线程
import threading
# 继承 Thread 类
class MyThread(threading.Thread):
def run(self):
for i in range(5):
print(i)
# 创建并启动线程
thread = MyThread()
thread.start()
# 等待线程执行完毕
thread.join()
print("Thread execution completed")
在这个例子中，定义了一个自定义的线程类 MyThread，并重写了 run() 方法。在主程序中，通过 MyThread() 创建线程，并通过 thread.start() 启动线程执行。
三、如何使用 threading 模块实现线程同步
当多个线程共享同一资源时，必须确保线程的访问是安全的。如果多个线程同时访问共享数据（如全局变量），可能会导致数据不一致或程序错误。为了解决这个问题，Python 提供了多种同步机制，最常用的是 锁（Lock）。
1. 使用锁（Lock）来保证线程同步
threading.Lock 是 Python 中最基本的同步机制。锁确保在同一时刻只有一个线程能够访问共享资源。当一个线程获得锁时，其他线程必须等待该线程释放锁才能继续执行。
示例：使用 Lock 确保线程安全
import threading
# 创建一个锁
lock = threading.Lock()
# 共享资源
counter = 0
# 线程执行的任务
def increment():
global counter
with lock: # 使用锁保护共享资源
temp = counter
temp += 1
counter = temp
# 创建多个线程
threads = []
for _ in range(100):
thread = threading.Thread(target=increment)
threads.append(thread)
thread.start()
# 等待所有线程执行完毕
for thread in threads:
thread.join()
print(f"Final counter value: {counter}")
在这个例子中：
lock = threading.Lock()创建了一个锁对象。with lock:确保每次只有一个线程能访问并修改counter变量。其他线程在此时会被阻塞，直到锁被释放。
2. 使用 threading.RLock
threading.RLock 是一种特殊类型的锁，其允许一个线程多次获取同一个锁，而不会发生死锁。这个特性对于需要在同一线程中多次访问共享资源的场景非常有用。
示例：使用 RLock
import threading
# 创建一个可重入锁
rlock = threading.RLock()
# 共享资源
counter = 0
# 线程执行的任务
def increment():
global counter
with rlock: # 使用 RLock 保护共享资源
temp = counter
temp += 1
counter = temp
# 创建多个线程
threads = []
for _ in range(100):
thread = threading.Thread(target=increment)
threads.append(thread)
thread.start()
# 等待所有线程执行完毕
for thread in threads:
thread.join()
print(f"Final counter value: {counter}")
与普通的 Lock 不同，RLock 允许同一线程多次获取锁，而不会造成死锁。因此，RLock 在某些复杂的递归操作或多次调用同步代码时更加方便。
3. 使用 threading.Condition 实现条件同步
threading.Condition 是一种更高级的同步机制，其允许线程等待某个条件的发生，而其他线程则可以通知它们条件已经满足。Condition 通常用于生产者-消费者问题等需要线程间协调的场景。
示例：使用 Condition 实现生产者-消费者模型
import threading
import time
# 创建条件变量
condition = threading.Condition()
# 共享资源
queue = []
# 生产者线程任务
def producer():
global queue
for i in range(5):
time.sleep(1)
with condition:
queue.append(i)
print(f"Produced {i}")
condition.notify() # 通知消费者
# 消费者线程任务
def consumer():
global queue
for _ in range(5):
with condition:
while not queue: # 队列为空时，消费者等待
condition.wait()
item = queue.pop(0)
print(f"Consumed {item}")
# 创建线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
# 启动线程
producer_thread.start()
consumer_thread.start()
# 等待线程完成
producer_thread.join()
consumer_thread.join()
print("All tasks completed")
在这个例子中：
condition.wait()使消费者在队列为空时进入等待状态。condition.notify()通知消费者线程继续执行。
四、总结
Python 中的 threading 模块提供了强大的线程创建和同步功能，能够轻松地实现并发程序。通过使用 threading.Thread 创建线程并使用 Lock、RLock 或 Condition 等同步机制，可以确保多线程程序的正确性，避免线程之间的竞争条件和数据不一致问题。多线程编程虽然提高了程序的执行效率，但在某些情况下（特别是 CPU 密集型任务）由于全局解释器锁（GIL）的存在，可能无法实现真正的并行执行。因此，理解线程的工作原理以及在适当的场景下选择合适的同步机制，对于编写高效的多线程程序至关重要。
有什么问题和经验想分享？欢迎在评论区交流、点赞、收藏、关注！