竞态条件

多个线程竞争同一资源

数据损坏

共享数据被错误修改

死锁问题

线程相互等待造成阻塞

Lock (互斥锁)

最基本的同步原语，一次只允许一个线程访问共享资源。

import threading

lock = threading.Lock()
shared_data = 0

def increment():
    global shared_data
    with lock:
        # 临界区代码
        shared_data += 1

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

for t in threads:
    t.join()

print(shared_data)  # 输出: 10

RLock (可重入锁)

允许同一个线程多次获取锁，避免死锁。

import threading

rlock = threading.RLock()

def recursive_func(count):
    with rlock:
        if count > 0:
            print(f"Count: {count}")
            recursive_func(count-1)

# 同一个线程可以多次获取RLock
thread = threading.Thread(target=recursive_func, args=(5,))
thread.start()
thread.join()

Semaphore (信号量)

控制同时访问共享资源的线程数量。

import threading
import time

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

def access_resource(thread_id):
    with semaphore:
        print(f"Thread {thread_id} 正在访问资源")
        time.sleep(2)
        print(f"Thread {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()

Condition (条件变量)

用于复杂的线程间通信和同步。

import threading

items = []
condition = threading.Condition()

def consumer():
    with condition:
        while not items:
            condition.wait()  # 等待生产者通知
        print(f"消费: {items.pop(0)}")

def producer():
    with condition:
        items.append("新产品")
        condition.notify()  # 通知消费者

# 创建线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

consumer_thread.start()
producer_thread.start()

producer_thread.join()
consumer_thread.join()

1. 最小化共享状态

尽可能减少线程间共享的数据量，优先使用线程局部存储或消息传递。

2. 使用高级抽象

优先使用concurrent.futures线程池等高级抽象，而不是直接操作线程。

3. 避免死锁

按固定顺序获取锁，使用带超时的锁，避免嵌套锁。

4. 优先使用队列

使用Queue进行线程间通信，比使用共享变量更安全。

5. 使用线程安全数据结构

优先选择线程安全的数据结构，如queue.Queue。

6. 避免全局变量

全局变量是常见的线程安全问题来源，尽量避免使用。