Python 多线程与多进程实现案例详解

一、多线程实现案例

1. 基础线程创建（函数式）

适用场景：简单的 I/O 阻塞任务（如文件批量下载）
实现说明：通过 threading.Thread 直接创建线程对象，适用于快速实现并发操作

import threading
import time

def download_task(url):
    print(f"开始下载：{url}")
    time.sleep(2)  # 模拟下载耗时
    print(f"完成下载：{url}")

urls = ["https://example.com/file1", 
        "https://example.com/file2"]

threads = []
for url in urls:
    thread = threading.Thread(target=download_task, args=(url,))
    thread.start()
    threads.append(thread)

for t in threads:
    t.join()

2. 线程同步与锁机制

适用场景：共享资源修改（如计数器累加）
实现说明：使用 Lock 保证数据操作的原子性

from threading import Thread, Lock

counter = 0
lock = Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

threads = [Thread(target=increment) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()

print(f"最终值：{counter}")  # 正确输出400000

3. 线程池批量处理

适用场景：大量短期任务（如URL批量请求）
实现说明：使用 ThreadPoolExecutor 实现线程复用

from concurrent.futures import ThreadPoolExecutor
import time

def process_data(data):
    time.sleep(0.5)
    return data * 2

with ThreadPoolExecutor(max_workers=4) as executor:
    futures = [executor.submit(process_data, i) for i in range(10)]
    results = [f.result() for f in futures]

print(results)  # [0,2,4,...,18]

二、多进程实现案例

1. 基础进程创建

适用场景：CPU密集型计算（如数学运算）
实现说明：通过 multiprocessing.Process 创建独立进程

import multiprocessing
import math

def calculate_factorial(n):
    print(math.factorial(n))

if __name__ == '__main__':
    nums = [1000, 1500, 2000]
    processes = []
    
    for n in nums:
        p = multiprocessing.Process(target=calculate_factorial, args=(n,))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

2. 进程池并行计算

适用场景：大数据分块处理（如日志分析）
实现说明：利用 Pool.map 实现任务分发

from multiprocessing import Pool
import os

def chunk_processor(chunk):
    print(f"进程{os.getpid()} 处理数据块")
    return sum(chunk)

if __name__ == '__main__':
    data = [range(i*1000, (i+1)*1000) for i in range(8)]
    
    with Pool(processes=4) as pool:
        results = pool.map(chunk_processor, data)
    
    print(f"合计：{sum(results)}")

3. 进程间通信

适用场景：跨进程数据共享（如实时监控系统）
实现说明：使用 Queue 实现进程安全通信

from multiprocessing import Process, Queue

def producer(q):
    for i in range(5):
        q.put(f"消息{i}")

def consumer(q):
    while True:
        item = q.get()
        if item is None: break
        print(f"收到：{item}")

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer, args=(q,))
    p2 = Process(target=consumer, args=(q,))
    
    p1.start(); p2.start()
    p1.join()
    q.put(None)  # 发送结束信号
    p2.join()

三、性能优化案例

1. 千万级数据处理加速

实现方案：结合内存映射与进程池

import multiprocessing
import os

def process_mmap(chunk):
    # 使用内存映射处理数据块
    return sum(chunk)

if __name__ == '__main__':
    file_size = os.path.getsize('bigdata.bin')
    chunk_size = file_size // 16
    
    with open('bigdata.bin', 'r+b') as f:
        with multiprocessing.Pool(8) as pool:
            args = [(f, i*chunk_size, chunk_size) for i in range(16)]
            results = pool.starmap(process_mmap, args)
    
    print(f"总计：{sum(results)}")

四、场景选择建议

​技术方案	​适用场景	​性能提升关键
多线程	I/O密集型（网络/文件操作）	利用I/O等待时间切换线程
多进程	CPU密集型（计算/数据处理）	突破GIL限制，利用多核CPU
线程池	短期重复任务（API调用）	减少线程创建销毁开销
进程池	长期计算任务（科学计算）	合理分配CPU核心资源

实际开发中建议：

1. I/O密集型优先使用线程池：concurrent.futures.ThreadPoolExecutor
2. CPU密集型优先使用进程池：multiprocessing.Pool
3. 复杂任务组合使用多进程+多线程架构