第一种方法: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 个质数的示例。
这个例子展示了如何在计算密集型任务中使用线程来提高效率,同时确保线程之间的数据共享是线程安全的。