线程不安全的那些事儿

线程不安全的例子

我们先来看一段代码：

import threading
import time
import random

# 共享变量
counter = 0

# 递增函数
def increment():
    global counter
    for _ in range(100000):
        # 读取当前值
        current_value = counter
        # 模拟一些计算延迟
        time.sleep(random.uniform(0, 0.0001))
        # 修改当前值
        current_value += 1
        # 写回共享变量
        counter = current_value

# 创建多个线程
threads = []
for i in range(100):  # 增加线程数量
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

# 打印最终结果
print(f"Final counter value: {counter}")

这段代码的目标很简单：我们创建了一个共享变量 counter，然后启动100个线程，每个线程都对 counter 进行100,000次递增操作。理论上，最终的 counter 值应该是100 * 100,000 = 10,000,000，对吧？

然而，运行结果却是这样的：

Final counter value: 100040

什么？10,000,000变成了100,040？这到底是怎么回事？

线程不安全的真相

让我们来揭开这个谜团。问题的根源在于多个线程同时访问和修改共享变量 counter 时，发生了竞态条件（race condition）。简单来说，当多个线程同时读取、修改和写回 counter 时，操作之间可能会互相干扰，导致最终结果不正确。

具体来说，以下是一个典型的竞态条件场景：

• 线程A读取 counter 的值（假设此时 counter 为100）。
• 线程B也读取 counter 的值（此时 counter 仍为100）。
• 线程A将 counter 的值加1，并写回（此时 counter 变为101）。
• 线程B也将 counter 的值加1，并写回（此时 counter 变为101，而不是102）。

由于线程A和线程B几乎同时操作 counter，导致其中一个操作被覆盖，最终结果少了一次递增。

如何解决线程不安全问题？

解决线程不安全问题的方法有很多，最常见的是使用锁（Lock）。锁可以确保在同一时刻只有一个线程能够访问共享资源，从而避免竞态条件。我们可以对上述代码进行修改，加入锁来保证线程安全：

import threading
import time
import random

# 共享变量
counter = 0
lock = threading.Lock()

# 递增函数
def increment():
    global counter
    for _ in range(100000):
        # 读取当前值
        with lock:
            current_value = counter
            # 模拟一些计算延迟
            time.sleep(random.uniform(0, 0.0001))
            # 修改当前值
            current_value += 1
            # 写回共享变量
            counter = current_value

# 创建多个线程
threads = []
for i in range(100):  # 增加线程数量
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

# 打印最终结果
print(f"Final counter value: {counter}")

在这段代码中，我们使用了 threading.Lock 来确保每次对 counter 的操作都是原子的（atomic）。这样一来，最终的 counter 值就会是我们期望的10,000,000。

结论

多线程编程中，线程不安全问题是一个常见但又容易被忽视的问题。通过这个简单的例子，我们可以看到竞态条件是如何影响程序的正确性的。希望这篇博客能帮助大家更好地理解线程不安全的影响，并在实际编程中避免类似的问题。

记住，锁虽然能解决线程不安全问题，但也会带来性能上的开销。因此，在实际应用中，我们需要权衡利弊，选择合适的并发控制策略。