python的多线程操作

第一种方法：import threading

举一个例子：

import threading

def worker(i, a):
    a[i] += 1

a = [i for i in range(100)]
threads = []

# 创建并启动线程
for i in range(len(a)):
    t = threading.Thread(target=worker, args=(i, a))
    threads.append(t)
    t.start()

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

print(a)

代碼解釋：
1、worker 函数：接收两个参数 i 和 a。i 是 a 列表中的索引，a 是要修改的列表。函数中将 a[i] 增加 1。
2、初始化 a 列表：使用列表推导式初始化 a 列表。
3 、创建线程：使用 threading.Thread 创建线程，目标是 worker 函数，传入参数 (i, a)。
4、启动和等待线程：启动所有线程，并使用 join 等待每个线程完成。

再举一个例子

import threading
import math

# 判断一个数是否为质数
def is_prime(num):
    if num <= 1:
        return False
    if num <= 3:
        return True
    if num % 2 == 0 or num % 3 == 0:
        return False
    i = 5
    while i * i <= num:
        if num % i == 0 or num % (i + 2) == 0:
            return False
        i += 6
    return True

# 定义线程要执行的任务函数
def worker(start, end, results_lock, results):
    local_results = []
    for num in range(start, end):
        if is_prime(num):
            local_results.append(num)
    
    with results_lock:
        results.extend(local_results)

# 初始化参数
start_range = 1
end_range = 100000
num_threads = 10
chunk_size = (end_range - start_range) // num_threads

results = []
results_lock = threading.Lock()  # 线程锁，确保线程安全

threads = []

# 创建并启动线程
for i in range(num_threads):
    chunk_start = start_range + i * chunk_size
    chunk_end = chunk_start + chunk_size
    if i == num_threads - 1:
        chunk_end = end_range  # 确保最后一个线程覆盖到最后一个范围
    
    t = threading.Thread(target=worker, args=(chunk_start, chunk_end, results_lock, results))
    threads.append(t)
    t.start()

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

# 打印结果
print(f"总共找到 {len(results)} 个质数")
print("质数示例:", results[:10])  # 只打印前10个质数

详解：

is_prime 函数：用于判断一个数是否为质数。这个函数进行了一些优化，以减少判断质数的计算时间。
worker 函数：负责计算从 start 到 end 范围内的质数，并将结果存储在 results 列表中。为了确保线程安全，使用 results_lock 进行同步。
初始化参数： start_range 和 end_range 是质数计算的范围。num_threads 是线程的数量，用于将计算任务分解为多个部分。chunk_size 是每个线程负责的计算范围。
创建和启动线程：为每个线程分配一个计算区间，并启动线程。
等待线程完成：使用 join() 等待所有线程执行完毕。
打印结果：输出找到的质数总数和前 10 个质数的示例。

运行结果：

这段代码将计算指定范围内的所有质数，并使用多个线程来加快计算速度。线程安全地将计算结果存储到共享列表中。打印结果时，你将看到找到的质数总数和前 10 个质数的示例。
这个例子展示了如何在计算密集型任务中使用线程来提高效率，同时确保线程之间的数据共享是线程安全的。