Python threading模块完全指南

1. 线程创建与启动

1.1 基础线程创建

通过继承Thread类创建自定义线程：

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, thread_id):
        super().__init__()
        self.thread_id = thread_id
        
    def run(self):
        print(f"线程 {self.thread_id} 开始运行")
        time.sleep(2)
        print(f"线程 {self.thread_id} 结束")

# 创建并启动线程
t1 = MyThread(1)
t2 = MyThread(2)

t1.start()
t2.start()

t1.join()
t2.join()

1.2 使用函数创建线程

直接传递目标函数创建线程：

def worker(message):
    print(f"工作线程: {message}")
    time.sleep(1)
    print("任务完成")

# 创建线程
t = threading.Thread(target=worker, args=("处理数据",))
t.start()
t.join()

2. 线程同步机制

2.1 使用Lock实现资源锁定

防止多个线程同时访问共享资源：

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        lock.acquire()  # 获取锁
        try:
            counter += 1
        finally:
            lock.release()  # 释放锁

threads = []
for i in range(5):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"最终计数: {counter}")  # 正确输出500000

2.2 使用RLock实现可重入锁

允许同一个线程多次获取锁：

rlock = threading.RLock()

def recursive_func(n):
    if n > 0:
        with rlock:  # 使用with语句自动管理锁
            print(f"层级 {n}")
            recursive_func(n-1)

t = threading.Thread(target=recursive_func, args=(3,))
t.start()
t.join()

3. 线程通信机制

3.1 使用Event进行线程通信

实现线程间的事件通知：

event = threading.Event()

def waiter():
    print("等待事件触发...")
    event.wait()  # 阻塞直到事件被设置
    print("事件已触发，继续执行")

def setter():
    time.sleep(2)
    print("设置事件")
    event.set()  # 设置事件

t1 = threading.Thread(target=waiter)
t2 = threading.Thread(target=setter)

t1.start()
t2.start()
t1.join()
t2.join()

3.2 使用Condition实现复杂同步

生产者-消费者模式实现：

items = []
condition = threading.Condition()

def consumer():
    with condition:
        while not items:
            print("没有产品，等待...")
            condition.wait()  # 等待通知
        item = items.pop()
        print(f"消费: {item}")

def producer():
    with condition:
        for i in range(3):
            items.append(f"产品{i}")
            print(f"生产: 产品{i}")
        condition.notify_all()  # 通知所有等待线程

# 创建线程
producers = [threading.Thread(target=producer) for _ in range(2)]
consumers = [threading.Thread(target=consumer) for _ in range(3)]

for t in producers + consumers:
    t.start()

for t in producers + consumers:
    t.join()

4. 其他实用工具

4.1 信号量(Semaphore)

控制对共享资源的访问数量：

semaphore = threading.Semaphore(3)  # 允许3个线程同时访问

def access_resource(thread_id):
    with semaphore:
        print(f"线程 {thread_id} 获取资源")
        time.sleep(2)
        print(f"线程 {thread_id} 释放资源")

threads = []
for i in range(10):
    t = threading.Thread(target=access_resource, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

4.2 定时器(Timer)

延迟执行线程任务：

def delayed_task():
    print("5秒后执行的任务")

timer = threading.Timer(5.0, delayed_task)
timer.start()
print("定时器已启动")