Python多线程操作全局变量的最佳方案

import threading

count = 0  # 全局变量

def worker():
    global count
    for _ in range(100000):
        count += 1  # 看似一行，实际是三步：读 → 改 → 写

threads = [threading.Thread(target=worker) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(count)  # 期望 1000000，实际经常是 99xxxx 这种奇怪的数

temp = count      # 第1步：读
temp = temp + 1   # 第2步：改
count = temp      # 第3步：写

import threading

count = 0
lock = threading.Lock()

def worker():
    global count
    for _ in range(100000):
        with lock:          # 核心：把读-改-写包在一个锁里
            count += 1

import threading
import queue

result_queue = queue.Queue()

def worker(n):
    # 每个线程只算自己的部分，不碰全局变量
    local_sum = sum(range(n))
    result_queue.put(local_sum)  # 扔进队列

threads = [threading.Thread(target=worker, args=(100000,)) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

# 主线程统一收结果
total = 0
while not result_queue.empty():
    total += result_queue.get()
print(total)

import threading

thread_local = threading.local()

def worker():
    # 每个线程拿到的是自己独立的副本，互不干扰
    thread_local.count = 0
    for _ in range(100000):
        thread_local.count += 1
    print(f"线程 {threading.current_thread().name} 的结果: {thread_local.count}")

threads = [threading.Thread(target=worker) for _ in range(3)]
for t in threads:
    t.start()
for t in threads:
    t.join()

from concurrent.futures import ThreadPoolExecutor, as_completed

def compute(n):
    return sum(range(n))

with ThreadPoolExecutor(max_workers=10) as executor:
    futures = [executor.submit(compute, 100000) for _ in range(10)]
    total = sum(f.result() for f in as_completed(futures))

print(total)

需要多线程共享一个变量？
├── 不需要共享 → 用 Queue 传参 ✅（首选）
├── 每个线程要独立副本 → 用 threading.local ✅
├── 必须共享且写多 → 用 Lock 保护 ✅
└── 只是偶尔读 → 直接读，不用锁（GIL够用）