Python——多线程的共享变量用法
在多线程编程中，共享变量 是一个重要但容易出错的概念。多个线程访问或修改同一个变量时，可能会引发竞态条件（race condition），导致数据错误或不可预测的行为。本教程详细介绍多线程中共享变量的使用方法，并结合代码示例与图解，帮助你更好地理解和避免常见问题。
一、什么是共享变量？
共享变量是指多个线程能够同时访问的变量。例如，多个线程对同一个全局变量或同一个对象的属性进行读写操作。
示例：共享变量引发竞态条件
import threading
# 初始化共享变量
shared_counter = 0
def increment():
global shared_counter
for _ in range(100000):
shared_counter += 1
# 创建线程
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
# 启动线程
thread1.start()
thread2.start()
# 等待线程结束
thread1.join()
thread2.join()
print(f"Final counter value: {shared_counter}")输出结果：
最终的 shared_counter 可能不会是预期的 200,000，原因是多个线程在同时修改变量时，操作并不是原子的，导致了竞态条件。
二、解决共享变量问题的方法
Python 提供了几种机制来安全地操作共享变量。
2.1 使用锁（Lock）
锁（threading.Lock）是最常用的方式，用于防止多个线程同时访问共享资源。
示例：使用锁解决竞态条件
import threading
shared_counter = 0
lock = threading.Lock()
def increment_with_lock():
global shared_counter
for _ in range(100000):
with lock: # 使用锁保护共享变量
shared_counter += 1
# 创建线程
thread1 = threading.Thread(target=increment_with_lock)
thread2 = threading.Thread(target=increment_with_lock)
# 启动线程
thread1.start()
thread2.start()
# 等待线程结束
thread1.join()
thread2.join()
print(f"Final counter value: {shared_counter}")输出结果：
无论运行多少次，shared_counter 的值始终是 200,000。
图解：
未加锁：
- 线程 1 和线程 2 可能同时读取相同的值，导致操作冲突。
加锁：
- 线程 1 获取锁后操作共享变量，线程 2 必须等待锁释放。
2.2 使用条件变量（Condition）
条件变量是高级的同步机制，可以让线程在满足特定条件时继续执行。
示例：生产者-消费者模型
import threading
import time
from queue import Queue
queue = Queue(maxsize=5)
condition = threading.Condition()
def producer():
for i in range(10):
with condition:
while queue.full():
condition.wait() # 等待队列有空位
queue.put(i)
print(f"Produced: {i}")
condition.notify_all() # 通知消费者
def consumer():
for _ in range(10):
with condition:
while queue.empty():
condition.wait() # 等待队列有数据
item = queue.get()
print(f"Consumed: {item}")
condition.notify_all() # 通知生产者
# 创建线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
# 启动线程
producer_thread.start()
consumer_thread.start()
# 等待线程结束
producer_thread.join()
consumer_thread.join()输出结果：
生产者和消费者交替运行，保证了队列的安全操作。
2.3 使用线程安全的数据结构
Python 的 queue 模块提供了线程安全的数据结构（如 Queue、LifoQueue 和 PriorityQueue），无需手动加锁。
示例：使用线程安全的队列
from queue import Queue
import threading
queue = Queue()
def producer():
for i in range(5):
queue.put(i)
print(f"Produced: {i}")
def consumer():
while not queue.empty():
item = queue.get()
print(f"Consumed: {item}")
# 创建线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
# 启动线程
producer_thread.start()
producer_thread.join() # 等生产者完成后再启动消费者
consumer_thread.start()
consumer_thread.join()三、避免死锁
在多线程中使用锁时，需要注意死锁问题。死锁通常发生在多个线程同时等待对方释放锁的情况下。
示例：避免死锁的技巧
使用 threading.Lock 或 threading.RLock 的上下文管理器，确保锁总是被正确释放。
改进的死锁避免代码
import threading
lock1 = threading.Lock()
lock2 = threading.Lock()
def thread1_task():
with lock1:
print("Thread 1 acquired lock1")
with lock2:
print("Thread 1 acquired lock2")
def thread2_task():
with lock2:
print("Thread 2 acquired lock2")
with lock1:
print("Thread 2 acquired lock1")
t1 = threading.Thread(target=thread1_task)
t2 = threading.Thread(target=thread2_task)
t1.start()
t2.start()
t1.join()
t2.join()通过控制加锁顺序或使用 RLock 可有效避免死锁。
四、图解多线程共享变量的流程
示例场景：两个线程共享一个计数器
- 线程 1 和线程 2 都尝试增加计数器。
- 加锁后，计数器修改变得有序且安全。
未加锁： 加锁：
线程 1 ---> 读取共享变量 线程 1 ---> 加锁
线程 2 ---> 读取共享变量 线程 2 ---> 等待锁释放
线程 1 ---> 修改变量 线程 1 ---> 修改变量
线程 2 ---> 修改变量 线程 1 ---> 释放锁五、总结与最佳实践
始终保护共享变量：
- 使用锁（
Lock或RLock）保护共享变量。 - 对复杂同步问题，考虑使用条件变量（
Condition）或线程安全的数据结构。
- 使用锁（
尽量避免手动加锁：
- 使用高层工具如
queue.Queue来自动管理线程安全。
- 使用高层工具如
小心死锁：
- 控制锁的顺序，避免多个锁之间的循环等待。
- 尽量使用上下文管理器来管理锁。
线程池的使用：
- 对于较大的并发任务，建议使用
concurrent.futures.ThreadPoolExecutor来简化线程管理。
- 对于较大的并发任务，建议使用
通过本文的讲解和示例代码，相信你已经掌握了在 Python 中多线程共享变量的安全使用方法。希望你能够灵活运用这些技巧，编写高效、稳定的多线程程序！