点赞、收藏、加关注，下次找我不迷路

一、啥是线程安全？

假设你开了一家包子铺，店里有个公共的蒸笼，里面放着刚蒸好的包子。现在有三个顾客同时来拿包子，要是每个人都随便伸手去拿，会不会出现混乱？比如第一个顾客拿的时候，第二个顾客也伸手，可能导致包子被抢破，或者数量统计出错。这时候，如果有一个服务员专门负责给顾客递包子，每次只让一个顾客拿，拿完再让下一个来，是不是就不会乱了？

在 Python 编程里，线程安全就跟这差不多。当多个线程（相当于多个顾客）同时操作共享资源（相当于公共蒸笼里的包子）时，如果没有合适的机制来协调，就可能导致数据不一致或者出现奇怪的问题。简单来说，线程安全就是保证多个线程访问共享资源时，结果和我们预期的一样，不会出错。

二、先搞懂啥是线程和进程

（一）进程：程序的一次运行

比如你打开一个 Python 脚本，让它运行起来，这就是一个进程。进程就像是一个独立的小房子，里面有自己的一套资源，比如内存、文件句柄等。不同的进程之间相互隔离，一般情况下不会互相干扰。

（二）线程：进程里的 “小工人”

一个进程里可以有多个线程，线程是程序执行的最小单元。比如一个视频播放软件的进程，里面可能有一个线程负责播放视频画面，一个线程负责处理声音，还有一个线程负责响应用户的操作。这些线程共享进程的资源，比如内存中的数据。

在 Python 中，我们可以通过threading模块来创建线程。看个简单的例子：

import threading
import time

def my_thread(name):
    time.sleep(1)
    print(f"线程{name}执行完毕")

if __name__ == "__main__":
    thread1 = threading.Thread(target=my_thread, args=("1",))
    thread2 = threading.Thread(target=my_thread, args=("2",))
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()

这里创建了两个线程，它们会分别执行my_thread函数。

三、为啥会出现线程不安全的情况？

（一）共享资源惹的祸

当多个线程都能访问同一个共享资源，比如全局变量、对象的属性、文件等，并且对这些资源进行修改操作时，就可能出现问题。因为线程的执行是抢占式的，CPU 会在多个线程之间来回切换，我们无法预测线程执行的顺序，这就可能导致数据的不一致。

（二）举个栗子：计数器的问题

假设我们有一个全局变量count，初始值为 0，现在有两个线程，每个线程都对count进行 1000 次加 1 操作。正常情况下，最后count应该是 2000。但实际情况可能不是这样，看下面的代码：

import threading

count = 0

def add_count():
    global count
    for _ in range(1000):
        count += 1

threads = []
for i in range(2):
    thread = threading.Thread(target=add_count)
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print("最终count的值：", count)

你可能会发现，运行结果往往小于 2000。这是因为count += 1这个操作在底层并不是原子操作，它实际上分为三步：读取count的值、加 1、写入count。当两个线程同时读取到相同的count值，然后各自加 1 写入，就会导致其中一个线程的操作被覆盖，从而出现数据错误。

四、常见的线程安全问题场景

为了让大家更清楚，咱用表格列出一些常见的线程不安全场景：

五、如何保证线程安全？

（一）互斥锁（Lock）：一次只能一个线程访问

互斥锁就像是一把钥匙，某个线程拿到这把钥匙后，才能访问共享资源，访问完再把钥匙交出来，其他线程才能拿到钥匙去访问。这样就能保证同一时间只有一个线程在操作共享资源。

在 Python 中，使用threading.Lock()来创建互斥锁。修改上面计数器的例子，加上互斥锁：

import threading

count = 0
lock = threading.Lock()

def add_count():
    global count
    for _ in range(1000):
        lock.acquire()  # 获得锁
        count += 1
        lock.release()  # 释放锁

threads = []
for i in range(2):
    thread = threading.Thread(target=add_count)
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print("最终count的值：", count)

这次运行结果就是 2000 了，因为每次只有一个线程能执行count += 1操作。

（二）可重入锁（RLock）：同一个线程可以多次获得锁

可重入锁是互斥锁的一个变种，它允许同一个线程在持有锁的情况下，再次获得该锁。比如在一个递归函数中，如果使用的是互斥锁，第一次获得锁后，递归调用时再次获取锁就会阻塞，导致死锁。而可重入锁不会出现这种情况。

import threading

lock = threading.RLock()

def recursive_function():
    lock.acquire()
    print("进入函数")
    # 递归调用
    recursive_function()
    lock.release()

（三）信号量（Semaphore）：控制同时访问资源的线程数量

信号量就像是一个停车场的栏杆，它允许一定数量的车辆（线程）进入，当进入的数量达到上限后，后面的车辆需要等待，直到有车辆离开。

比如我们限制同时最多有 3 个线程访问共享资源：

import threading
import time

semaphore = threading.Semaphore(3)

def worker():
    semaphore.acquire()
    print(f"线程{threading.get_ident()}获得信号量")
    time.sleep(2)
    semaphore.release()
    print(f"线程{threading.get_ident()}释放信号量")

for i in range(5):
    thread = threading.Thread(target=worker)
    thread.start()

（四）条件变量（Condition）：协调多个线程之间的执行顺序

条件变量通常和锁一起使用，它可以让一个线程等待某个条件满足后再继续执行。比如生产者 - 消费者模型中，消费者线程可以等待生产者线程生产数据后再消费。

import threading

condition = threading.Condition()
buffer = []
max_size = 5

def producer():
    with condition:
        while len(buffer) == max_size:
            condition.wait()  # 等待缓冲区不满
        buffer.append("产品")
        print("生产了一个产品，缓冲区现有", len(buffer))
        condition.notify_all()  # 通知消费者

def consumer():
    with condition:
        while len(buffer) == 0:
            condition.wait()  # 等待缓冲区不空
        product = buffer.pop()
        print("消费了一个产品，缓冲区现有", len(buffer))
        condition.notify_all()  # 通知生产者

（五）队列（Queue）：线程安全的数据结构

Python 中的queue模块提供了线程安全的队列，包括 FIFO 队列、LIFO 队列和优先队列。使用队列时，不需要我们自己处理锁，因为队列内部已经实现了线程安全机制。

import threading
import queue

q = queue.Queue()

def producer():
    for i in range(5):
        q.put(i)
        print(f"生产者放入数据{i}")

def consumer():
    while True:
        data = q.get()
        print(f"消费者取出数据{data}")
        q.task_done()  # 通知队列任务完成

thread1 = threading.Thread(target=producer)
thread2 = threading.Thread(target=consumer)
thread1.start()
thread2.start()
thread1.join()
thread2.join()

六、Python 中线程安全的数据结构

对于普通的列表、字典等数据结构，在多个线程中进行修改操作时是线程不安全的，如果需要在多个线程中使用，需要自己加锁保护。

七、线程安全不难记，这几点要注意

1. 共享资源要保护：只要有多个线程访问共享资源，并且有写操作，就需要考虑线程安全问题。

2. 锁机制是法宝：互斥锁、可重入锁、信号量、条件变量，根据不同场景选择合适的锁。

3. 能用队列就用队列：队列是 Python 中自带的线程安全数据结构，简单方便，能解决很多问题。

4. 避免共享资源：如果可能，尽量让每个线程使用自己独立的资源，避免共享，从根本上解决线程安全问题。

线程安全是 Python 多线程编程中非常重要的一个概念，理解它并掌握相应的解决方法，能让我们在编写多线程程序时避免很多坑。记住，当多个线程操作共享资源时，一定要考虑是否会出现数据不一致的问题，根据实际情况选择合适的线程同步机制，比如锁、信号量、条件变量或者使用线程安全的数据结构队列。