# 导入Python内置多线程模块
import threading

# ======================================
# 一、未加锁：多线程共享变量出现「竞态条件」
# ======================================
# 定义共享变量：两个线程都会修改它
counter = 0

def increment():
    # 声明使用全局变量counter，否则函数会把它当作局部变量处理
    global counter
    # 每个线程循环10万次，每次给counter+1
    for _ in range(100000):
        # ⚠️ 关键问题：这行代码不是「原子操作」！
        # Python中 `counter += 1` 会被拆成3个独立步骤执行：
        # 1. 读取当前counter的值 → temp = counter
        # 2. 对temp加1 → temp = temp + 1
        # 3. 把temp的值写回counter → counter = temp
        # 两个线程同时执行时，可能读取到同一个temp值，导致加1结果被覆盖
        counter += 1

# 创建两个线程，执行同一个increment函数
t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)

# 启动两个线程（并发执行，不会互相等待）
t1.start()
t2.start()

# 主线程等待两个子线程执行完毕
t1.join()
t2.join()

# 预期结果：200000（10万+10万）
# 实际结果：每次运行都不同（比如178234、190123...），永远达不到预期值
print(f"❌ 未加锁，共享变量结果：{counter}")

# ======================================
# 二、加锁解决：用Lock保证数据安全
# ======================================
# 重置共享变量，重新演示
counter = 0
# 创建一个线程互斥锁（Mutex），用于保护共享变量
lock = threading.Lock()

def safe_increment():
    global counter
    for _ in range(100000):
        # ✅ 使用with语句自动加锁/释放锁（Python推荐写法）
        # 原理：当一个线程进入with块时，会「获取锁」，其他线程会被阻塞在这里
        # 直到当前线程执行完with块内的代码，锁被自动释放，其他线程才能进入
        with lock:
            # 同一时刻只有一个线程能执行这行，把非原子操作变成「逻辑上的原子操作」
            counter += 1

# 重新创建并启动线程
t1 = threading.Thread(target=safe_increment)
t2 = threading.Thread(target=safe_increment)
t1.start()
t2.start()
t1.join()
t2.join()

# 加锁后，结果永远是预期的200000
print(f"✅ 加锁后，共享变量结果：{counter}")
# ⚠️ 加锁会降低速度（线程需要等锁）。只在必须共享数据时加锁，大多数情况下可以让每个线程有自己的本地数据，避免共享。