在处理多线程环境下的测试时，如何确保测试的正确性和稳定性？

import threading
class Counter:
    def __init__(self):
        self.count = 0
        self.lock = threading.Lock()
    def increment(self):
        with self.lock:
            self.count += 1
    def get_count(self):
        return self.count
# 测试
counter = Counter()
threads = []
for _ in range(100):
    t = threading.Thread(target=counter.increment)
    threads.append(t)
    t.start()
for t in threads:
    t.join()
print(f"Final count: {counter.get_count()}")
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

import threading
def method1(lock1, lock2):
    with lock1:
        print("Thread 1: Acquired lock1")
        with lock2:
            print("Thread 1: Acquired lock2")
def method2(lock1, lock2):
    with lock2:
        print("Thread 2: Acquired lock2")
        with lock1:
            print("Thread 2: Acquired lock1")
# 创建锁
lock1 = threading.Lock()
lock2 = threading.Lock()
# 创建线程
t1 = threading.Thread(target=method1, args=(lock1, lock2))
t2 = threading.Thread(target=method2, args=(lock1, lock2))
# 启动线程
t1.start()
t2.start()
# 等待线程结束
t1.join()
t2.join()
为了避免死锁，可以调整锁的获取顺序，或者使用超时机制：
import threading
def method1(lock1, lock2):
    if lock1.acquire(timeout=1):
        try:
            print("Thread 1: Acquired lock1")
            if lock2.acquire(timeout=1):
                try:
                    print("Thread 1: Acquired lock2")
                finally:
                    lock2.release()
        finally:
            lock1.release()
def method2(lock1, lock2):
    if lock2.acquire(timeout=1):
        try:
            print("Thread 2: Acquired lock2")
            if lock1.acquire(timeout=1):
                try:
                    print("Thread 2: Acquired lock1")
                finally:
                    lock1.release()
        finally:
            lock2.release()
# 创建锁
lock1 = threading.Lock()
lock2 = threading.Lock()
# 创建线程
t1 = threading.Thread(target=method1, args=(lock1, lock2))
t2 = threading.Thread(target=method2, args=(lock1, lock2))
# 启动线程
t1.start()
t2.start()
# 等待线程结束
t1.join()
t2.join()
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.

import sqlite3
import concurrent.futures
import threading
# 数据库连接池
connection_pool = []
pool_size = 5
# 初始化连接池
def init_connection_pool():
    for _ in range(pool_size):
        conn = sqlite3.connect(':memory:')
        connection_pool.append(conn)
# 获取连接
def get_connection_from_pool():
    with pool_lock:
        if connection_pool:
            return connection_pool.pop()
        else:
            return None
# 释放连接
def release_connection_to_pool(conn):
    with pool_lock:
        connection_pool.append(conn)
# 处理请求
def process_request(request_id):
    conn = get_connection_from_pool()
    if conn:
        try:
            cursor = conn.cursor()
            cursor.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, value TEXT)")
            cursor.execute("INSERT INTO test (value) VALUES (?)", (f"Request {request_id}",))
            conn.commit()
        except Exception as e:
            print(f"Error: {e}")
        finally:
            release_connection_to_pool(conn)
# 初始化连接池
init_connection_pool()
# 线程池
executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
# 提交任务
requests = [i for i in range(100)]
for request in requests:
    executor.submit(process_request, request)
# 等待所有任务完成
executor.shutdown(wait=True)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.

import sqlite3
import threading
# 数据库连接
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()
# 创建表
cursor.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, value TEXT)")
conn.commit()
# 事务管理
def update_value(value):
    with conn:
        cursor = conn.cursor()
        cursor.execute("INSERT INTO test (value) VALUES (?)", (value,))
        # 如果任何一步失败，事务将回滚
# 创建线程
threads = []
for i in range(100):
    t = threading.Thread(target=update_value, args=(f"Value {i}",))
    threads.append(t)
    t.start()
# 等待所有线程结束
for t in threads:
    t.join()
# 查询结果
cursor.execute("SELECT * FROM test")
rows = cursor.fetchall()
for row in rows:
    print(row)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

import sqlite3
import threading
# 数据库连接
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()
# 创建表
cursor.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, value TEXT, version INTEGER DEFAULT 0)")
conn.commit()
# 乐观锁
def update_value_optimistic(id, value, expected_version):
    with conn:
        cursor = conn.cursor()
        cursor.execute("UPDATE test SET value = ?, version = version + 1 WHERE id = ? AND version = ?", (value, id, expected_version))
        if cursor.rowcount == 0:
            raise Exception("Optimistic lock failed")
# 创建线程
def worker(id, value):
    while True:
        cursor.execute("SELECT value, version FROM test WHERE id = ?", (id,))
        row = cursor.fetchone()
        if row:
            current_value, current_version = row
            try:
                update_value_optimistic(id, value, current_version)
                break
            except Exception as e:
                print(f"Worker {id}: {e}")
# 初始化数据
cursor.execute("INSERT INTO test (id, value) VALUES (?, ?)", (1, "Initial Value"))
conn.commit()
# 创建线程
threads = []
for i in range(10):
    t = threading.Thread(target=worker, args=(1, f"Value {i}"))
    threads.append(t)
    t.start()
# 等待所有线程结束
for t in threads:
    t.join()
# 查询结果
cursor.execute("SELECT * FROM test")
row = cursor.fetchone()
print(row)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.