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 ---> 释放锁

五、总结与最佳实践

1. 始终保护共享变量：

   • 使用锁（Lock 或 RLock）保护共享变量。
   • 对复杂同步问题，考虑使用条件变量（Condition）或线程安全的数据结构。

2. 尽量避免手动加锁：

   • 使用高层工具如 queue.Queue 来自动管理线程安全。

3. 小心死锁：

   • 控制锁的顺序，避免多个锁之间的循环等待。
   • 尽量使用上下文管理器来管理锁。

4. 线程池的使用：

   • 对于较大的并发任务，建议使用 concurrent.futures.ThreadPoolExecutor 来简化线程管理。

通过本文的讲解和示例代码，相信你已经掌握了在 Python 中多线程共享变量的安全使用方法。希望你能够灵活运用这些技巧，编写高效、稳定的多线程程序！