Python使用多进程执行同一个函数的多种方法

import multiprocessing
import time

def worker(task_name, duration):
    print(f"进程 {task_name} 开始执行，预计耗时 {duration} 秒")
    time.sleep(duration)
    print(f"进程 {task_name} 执行完成")
    return f"{task_name} 处理结果"

if __name__ == "__main__":
    processes = []
    tasks = [("任务A", 2), ("任务B", 3), ("任务C", 1)]
    
    # 创建并启动多个进程
    for name, duration in tasks:
        p = multiprocessing.Process(target=worker, args=(name, duration))
        processes.append(p)
        p.start()
        print(f"已启动进程: {name}")
    
    # 等待所有进程完成
    for p in processes:
        p.join()
    
    print("所有进程执行完毕")

import multiprocessing
import os

def worker(x):
    print(f"进程 {os.getpid()} 正在处理数据: {x}")
    result = x * x  # 模拟计算任务
    return result

if __name__ == "__main__":
    # 创建进程池，进程数通常设为CPU核心数
    with multiprocessing.Pool(processes=multiprocessing.cpu_count()) as pool:
        data = [1, 2, 3, 4, 5, 6, 7, 8]
        
        # 方法1: map - 阻塞式，按顺序返回结果
        results = pool.map(worker, data)
        print(f"map 结果: {results}")
        
        # 方法2: map_async - 非阻塞式
        async_result = pool.map_async(worker, data)
        results_async = async_result.get()  # 获取结果时会阻塞
        print(f"map_async 结果: {results_async}")

import multiprocessing
import time
import random

def worker(task_id):
    sleep_time = random.uniform(0.5, 2.0)
    time.sleep(sleep_time)
    return f"任务{task_id} 完成，耗时{sleep_time:.2f}秒"

if __name__ == "__main__":
    with multiprocessing.Pool(4) as pool:
        # 提交多个异步任务
        async_results = []
        for i in range(6):
            result = pool.apply_async(worker, args=(i,))
            async_results.append(result)
        
        print("所有任务已提交，主进程可继续执行其他工作...")
        
        # 按完成顺序获取结果（无序）
        for result in async_results:
            print(result.get())  # 阻塞直到有结果可用

def worker(queue):
    data = queue.get()
    processed = f"处理后的: {data}"
    queue.put(processed)

def error_callback(error):
    print(f"任务执行出错: {error}")

pool.apply_async(worker, args=(data,), error_callback=error_callback)

# 根据任务类型调整参数
results = pool.map(worker, data, chunksize=len(data)//multiprocessing.cpu_count())

import multiprocessing
import requests

def download_url(url):
    try:
        response = requests.get(url, timeout=10)
        return f"{url}: 成功, 大小 {len(response.content)} bytes"
    except Exception as e:
        return f"{url}: 失败, 错误 {str(e)}"

if __name__ == "__main__":
    urls = [
        "https://httpbin.org/delay/1",
        "https://httpbin.org/delay/2", 
        "https://httpbin.org/delay/1"
    ]
    
    with multiprocessing.Pool(3) as pool:
        results = pool.map(download_url, urls)
    
    for result in results:
        print(result)