一文教你学会使用Python中的多处理模块

import multiprocessing

def worker_function(arg):
    # 在这里执行任务
    print(f"Worker process with argument {arg}")

if __name__ == "__main__":
    # 创建进程池，指定进程数量（通常为 CPU 核心数）
    pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())

# 提交任务到进程池
    result = pool.map(worker_function, [1, 2, 3, 4, 5])

# 关闭进程池，释放资源
    pool.close()
    pool.join()

import concurrent.futures

if __name__ == "__main__":
    # 创建一个进程池执行器
    with concurrent.futures.ProcessPoolExecutor() as executor:

# 提交任务给执行器
        results = [executor.submit(worker_function, arg) for arg in [1, 2, 3, 4, 5]]

# 获取任务结果
        for future in concurrent.futures.as_completed(results):
            result = future.result()
            print(result)

import multiprocessing
 
def process_data_chunk(chunk):
    # 在这里处理数据块
    return processed_chunk
 
if __name__ == "__main__":
    data = load_large_dataset()  # 加载大数据集
    num_processes = multiprocessing.cpu_count()
    
    # 将数据分成多个块，每个块交给一个进程处理
    data_chunks = split_data_into_chunks(data, num_processes)
    
    with multiprocessing.Pool(processes=num_processes) as pool:
        processed_chunks = pool.map(process_data_chunk, data_chunks)
    
    # 合并处理后的数据块
    final_result = combine_processed_chunks(processed_chunks)

import concurrent.futures
import requests
 
def fetch_url(url):
    response = requests.get(url)
    return response.text
 
if __name__ == "__main__":
    urls = ["https://example.com/page1", "https://example.com/page2", "https://example.com/page3"]
    
    with concurrent.futures.ThreadPoolExecutor() as executor:
        results = list(executor.map(fetch_url, urls))

import multiprocessing
 
def calculate_pi(digits):
    # 在这里计算π的指定位数
    return pi_value
 
if __name__ == "__main__":
    num_digits = 1000
    num_processes = multiprocessing.cpu_count()
    
    with multiprocessing.Pool(processes=num_processes) as pool:
        pi_values = pool.map(calculate_pi, [num_digits] * num_processes)
    
    final_pi = combine_pi_values(pi_values)

import concurrent.futures
import asyncio
 
async def async_task(task_id):
    # 在这里执行异步任务
    return result
 
async def main():
    tasks = [async_task(i) for i in range(10)]
    
    with concurrent.futures.ThreadPoolExecutor() as executor:
        results = await asyncio.gather(*tasks)
    
    # 处理异步任务的结果
 
if __name__ == "__main__":
    asyncio.run(main())