Python 类变量修改的压力测试：高并发场景

你想在 Python 中测试高并发场景下类变量的修改压力，核心是验证多线程 / 多进程并发修改类变量时的安全性、性能表现，以及可能出现的线程安全问题。

一、测试方案设计思路

核心目标 ：模拟高并发下多个执行单元（线程 / 进程）同时读写类变量，观察：
- 是否出现数据不一致（线程安全问题）
- 并发量与执行效率的关系
- 不同同步机制（锁）对性能的影响
测试场景 ：
- 无锁场景：验证并发修改的安全性问题
- 有锁场景（线程锁 / 进程锁）：验证同步机制的有效性
- 不同并发量（10/100/1000 个执行单元）对比
测试对象 ：
- 类变量（属于类本身，所有实例共享）
- 测试操作：对类变量执行「自增」（读 - 改 - 写原子操作）

二、完整测试代码（线程 + 进程场景）

需要先安装依赖（如需进程间通信）：

bash

运行

复制代码

pip install multiprocessing  # Python 标准库，通常默认已安装

python

运行

复制代码

import threading
import multiprocessing
import time
import sys

# 定义测试类（包含共享类变量）
class Counter:
    # 类变量：所有实例/线程/进程共享
    count = 0
    # 线程锁（用于线程安全场景）
    thread_lock = threading.Lock()
    # 进程锁（用于进程安全场景，multiprocessing 跨进程共享需特殊处理）
    process_lock = multiprocessing.Lock()

# ------------------------------
# 1. 线程并发测试（同一进程内共享类变量）
# ------------------------------
def thread_worker(lock_enabled=True, iterations=1000):
    """线程工作函数：修改类变量"""
    for _ in range(iterations):
        if lock_enabled:
            # 加锁保证原子操作
            with Counter.thread_lock:
                Counter.count += 1
        else:
            # 无锁：直接修改（存在线程安全问题）
            Counter.count += 1

def test_thread_concurrency(thread_num=10, iterations=1000, lock_enabled=True):
    """测试线程并发修改类变量"""
    # 重置类变量
    Counter.count = 0
    start_time = time.time()
    
    # 创建线程池
    threads = []
    for _ in range(thread_num):
        t = threading.Thread(target=thread_worker, args=(lock_enabled, iterations))
        threads.append(t)
        t.start()
    
    # 等待所有线程完成
    for t in threads:
        t.join()
    
    end_time = time.time()
    elapsed = end_time - start_time
    expected = thread_num * iterations  # 理论预期值
    actual = Counter.count  # 实际结果
    consistent = (actual == expected)  # 是否数据一致
    
    return {
        "场景": f"线程并发（{thread_num}线程，{iterations}次/线程）",
        "是否加锁": lock_enabled,
        "预期结果": expected,
        "实际结果": actual,
        "数据一致": consistent,
        "耗时(秒)": round(elapsed, 4)
    }

# ------------------------------
# 2. 进程并发测试（跨进程共享类变量需特殊处理）
# ------------------------------
# 注意：多进程中，类变量默认是每个进程的副本，需用 Manager 共享
def init_process(shared_counter, lock):
    """进程初始化：传递共享计数器和锁（跨进程共享）"""
    global counter, process_lock
    counter = shared_counter
    process_lock = lock

def process_worker(iterations=1000, lock_enabled=True):
    """进程工作函数：修改共享计数器（模拟类变量）"""
    for _ in range(iterations):
        if lock_enabled:
            with process_lock:
                counter.value += 1
        else:
            counter.value += 1

def test_process_concurrency(process_num=10, iterations=1000, lock_enabled=True):
    """测试进程并发修改共享变量（模拟类变量跨进程共享）"""
    # 多进程共享变量：用 Manager.Value 创建可跨进程修改的整数
    manager = multiprocessing.Manager()
    shared_counter = manager.Value('i', 0)  # 'i' 表示整数类型
    process_lock = multiprocessing.Lock()
    
    start_time = time.time()
    
    # 创建进程池（传递共享变量和锁）
    processes = []
    for _ in range(process_num):
        p = multiprocessing.Process(
            target=process_worker,
            args=(iterations, lock_enabled),
            initargs=(shared_counter, process_lock)  # 进程初始化参数
        )
        processes.append(p)
        p.start()
    
    # 等待所有进程完成
    for p in processes:
        p.join()
    
    end_time = time.time()
    elapsed = end_time - start_time
    expected = process_num * iterations
    actual = shared_counter.value
    consistent = (actual == expected)
    
    # 关闭 Manager
    manager.shutdown()
    
    return {
        "场景": f"进程并发（{process_num}进程，{iterations}次/进程）",
        "是否加锁": lock_enabled,
        "预期结果": expected,
        "实际结果": actual,
        "数据一致": consistent,
        "耗时(秒)": round(elapsed, 4)
    }

# ------------------------------
# 3. 执行压力测试并输出结果
# ------------------------------
def run_stress_test():
    """执行完整压力测试：不同并发量+有无锁对比"""
    # 测试配置：并发量（线程/进程数）和每个执行单元的迭代次数
    test_cases = [
        # 线程测试用例
        ("thread", 10, 10000),   # 10线程，每线程1万次
        ("thread", 100, 10000),  # 100线程，每线程1万次
        ("thread", 1000, 1000),  # 1000线程，每线程1千次
        # 进程测试用例（进程数不宜过多，避免系统资源耗尽）
        ("process", 10, 10000),  # 10进程，每进程1万次
        ("process", 20, 10000),  # 20进程，每进程1万次
    ]
    
    print("=" * 80)
    print("Python 类变量高并发修改压力测试结果")
    print("=" * 80)
    
    for case_type, concurrency, iterations in test_cases:
        # 分别测试「无锁」和「有锁」场景
        for lock_enabled in [False, True]:
            if case_type == "thread":
                result = test_thread_concurrency(concurrency, iterations, lock_enabled)
            else:
                result = test_process_concurrency(concurrency, iterations, lock_enabled)
            
            # 格式化输出
            print(f"\n【{result['场景']}】")
            print(f"  加锁状态: {'是' if result['是否加锁'] else '否'}")
            print(f"  预期结果: {result['预期结果']}")
            print(f"  实际结果: {result['实际结果']} ({'一致' if result['数据一致'] else '不一致'})")
            print(f"  耗时: {result['耗时(秒)']} 秒")
    
    print("\n" + "=" * 80)

if __name__ == "__main__":
    # 限制递归深度（避免高并发时出错）
    sys.setrecursionlimit(10000)
    run_stress_test()

三、代码关键说明

线程安全问题：
- 无锁场景下，Counter.count += 1 不是原子操作（实际是「读 - 改 - 写」三步），多线程并发时会出现数据覆盖，导致实际结果小于预期。
- 加锁后（threading.Lock），强制同一时间只有一个线程修改变量，保证数据一致性，但会引入锁开销。
进程并发特殊处理：
- Python 多进程中，每个进程有独立的内存空间，类变量默认不共享，需用 multiprocessing.Manager 创建跨进程共享变量。
- 进程锁（multiprocessing.Lock）用于解决跨进程的并发安全问题。
压力测试维度：
- 并发量：从 10 到 1000 逐步提升，观察性能变化。
- 迭代次数：每个执行单元的修改次数，控制总操作量。
- 有无锁对比：验证同步机制的必要性和性能损耗。

四、典型测试结果分析（示例）

表格

场景	加锁	预期结果	实际结果	数据一致	耗时 (秒)
10 线程 + 1 万次 / 线程	否	100000	89235	否	0.12
10 线程 + 1 万次 / 线程	是	100000	100000	是	0.35
1000 线程 + 1 千次 / 线程	否	1000000	789542	否	1.05
1000 线程 + 1 千次 / 线程	是	1000000	1000000	是	3.28
10 进程 + 1 万次 / 进程	否	100000	91234	否	0.87
10 进程 + 1 万次 / 进程	是	100000	100000	是	2.15

关键结论：

无锁并发必然导致数据不一致，高并发下更严重。
加锁能保证数据安全，但会增加耗时（锁竞争 overhead）。
进程并发的开销远大于线程（进程切换成本高），相同并发量下耗时更长。

Python 类变量修改的压力测试：高并发场景

一、测试方案设计思路

二、完整测试代码（线程 + 进程场景）

三、代码关键说明

四、典型测试结果分析（示例）

总结