Python多线程程序中，多个线程往往需要操作同一份业务数据，例如累计请求次数、缓存计算结果或传递任务状态。由于线程调度具有不确定性，若不对共享数据的访问加以约束，就很容易出现数据不一致、丢失更新等问题。本文围绕多线程数据共享的核心难点，逐一分析可行的数据安全传递方案。
为什么普通变量共享会出问题
很多初学者认为，在Python里只要把变量定义为全局或者在类里写成实例属性，各个线程就能直接读写，逻辑上似乎通顺。但实际上，像counter = counter + 1这种操作，在字节码层面会被拆成读取、计算、写回三步。线程A刚读完旧值就被挂起，线程B也读完同样的旧值并写回，等A恢复后再写回，最终结果只加了一次而不是两次。
下面这段示例代码刻意放大了这种竞态。我们启动十个线程，每个线程都对全局变量累加十万次，理论上结果应该是一百万，但每次运行几乎都少于这个值。
import threading
counter = 0
def worker():
global counter
for _ in range(100000):
counter = counter + 1
threads = []
for i in range(10):
t = threading.Thread(target=worker)
threads.append(t)
t.start()
for t in threads:
t.join()
print("final counter:", counter)
这个现象说明，即便Python有全局解释器锁（GIL），它也只是保证同一时刻只有一个线程执行字节码，并不保证某段业务逻辑不被中途打断。因此，共享数据必须依靠显式的同步工具。
使用锁机制保护临界区
最直观的方案是使用threading.Lock。锁只有两个状态：锁定与未锁定。线程进入临界区前调用acquire()，离开时调用release()。更推荐用with语句，它能确保即使代码抛出异常也会自动释放锁，避免死锁。
把前面的例子加上锁之后，结果就稳定为一百万。锁的本质是让“读取-修改-写回”成为一个不可分割的整体，其他线程必须等待当前线程完成。
import threading
counter = 0
lock = threading.Lock()
def worker():
global counter
for _ in range(100000):
with lock:
counter = counter + 1
threads = []
for i in range(10):
t = threading.Thread(target=worker)
threads.append(t)
t.start()
for t in threads:
t.join()
print("final counter:", counter)
锁方案的优点是实现简单、语义清晰，适合共享变量较少且冲突频繁的场景。缺点是如果临界区过大，会削弱并发性能；另外多个锁交织时容易写出死锁代码，需要谨慎设计加锁顺序。
通过队列实现线程间数据传递
另一种思路是尽量不共享状态，而是用消息传递代替。Python标准库中的queue.Queue是线程安全的，内部已经用锁实现，开发者可以直接往里放数据、取数据。典型场景是一个线程生产任务，多个线程消费任务，彼此不需要知道对方的存在。
下面的例子里，主线程往队列里塞数字，三个工作线程不断取出并做平方计算，再把结果放回结果队列。这样原始数据和计算结果都是通过队列流转，没有暴露裸变量。
import threading
import queue
task_q = queue.Queue()
result_q = queue.Queue()
def worker():
while True:
item = task_q.get()
if item is None:
break
result_q.put(item * item)
task_q.task_done()
threads = []
for i in range(3):
t = threading.Thread(target=worker)
t.start()
threads.append(t)
for n in range(10):
task_q.put(n)
for _ in range(3):
task_q.put(None)
for t in threads:
t.join()
while not result_q.empty():
print(result_q.get())
队列方案解耦了生产者和消费者，扩展性也好，还能天然支持背压（队列满时生产者阻塞）。代价是相较于直接读写变量，多了序列化与上下文切换开销，且代码结构上要适应“消息驱动”的写法。
线程局部变量避免不必要的共享
有些数据其实不需要在线程之间共享，比如每个线程独立的数据库连接、临时缓冲区。这时可以用threading.local()创建线程局部变量，每个线程看到的是自己的独立副本，互不干扰，也就谈不上数据安全之争。
示例如下，我们给每个线程设置一个名字，读取时只会拿到本线程写入的值，完全不需要加锁。
import threading
local_data = threading.local()
def worker(name):
local_data.name = name
print(threading.current_thread().name, "sees", local_data.name)
threads = []
for i in range(3):
t = threading.Thread(target=worker, args=("thread-%d" % i,))
t.start()
threads.append(t)
for t in threads:
t.join()
线程局部变量适合保存“线程私有上下文”，能减少锁竞争。但它不能用来做汇总统计，因为各线程的数据彼此不可见，若需聚合仍要借助锁或队列回传。
方案对比与选型建议
为了更直观地选择合适方案，我们可以从共享需求、复杂度、性能三个维度对比。
| 方案 | 是否共享状态 | 实现难度 | 适用场景 |
|---|---|---|---|
| Lock | 是 | 低 | 少量变量、频繁读写计数 |
| Queue | 否（消息传递） | 中 | 任务分发、生产消费模型 |
| local | 否（线程私有） | 低 | 线程独立上下文、连接池 |
在实际项目中，常常组合使用。例如用线程局部变量持有数据库连接，用队列接收任务，用锁保护最终的统计指标。理解每种方案背后的内存可见性与原子性保证，才能写出既正确又高效的多线程Python程序。