python3如何并发执行函数demo

Python3 并发执行函数的方法有多种，包括使用多线程、多进程和异步编程。 主要的方法包括线程池、进程池和 asyncio 库。下面将详细介绍这些方法，并给出具体的示例代码。

一、使用线程池并发执行函数

Python 的 concurrent.futures.ThreadPoolExecutor 类可以方便地创建和管理线程池，适用于 I/O 密集型任务。

线程池基础示例

import concurrent.futures
import time
def task(n):
    print(f'Task {n} started')
    time.sleep(2)
    print(f'Task {n} finished')
    return n * 2
if __name__ == "__main__":
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        futures = [executor.submit(task, i) for i in range(10)]
        for future in concurrent.futures.as_completed(futures):
            print(f'Result: {future.result()}')

在这个示例中，我们创建了一个包含 5 个线程的线程池，并提交了 10 个任务，每个任务会在 2 秒后完成。最终输出每个任务的结果。

二、使用进程池并发执行函数

对于 CPU 密集型任务，使用 concurrent.futures.ProcessPoolExecutor 类来创建和管理进程池。

进程池基础示例

import concurrent.futures
import time
def task(n):
    print(f'Task {n} started')
    time.sleep(2)
    print(f'Task {n} finished')
    return n * 2
if __name__ == "__main__":
    with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
        futures = [executor.submit(task, i) for i in range(10)]
        for future in concurrent.futures.as_completed(futures):
            print(f'Result: {future.result()}')

这个示例与线程池的示例类似，只是使用了 ProcessPoolExecutor 来替代 ThreadPoolExecutor，适合 CPU 密集型任务。

三、使用 asyncio 并发执行函数

asyncio 是 Python 的异步 I/O 框架，适用于 I/O 密集型任务和高并发场景。

asyncio 基础示例

import asyncio
async def task(n):
    print(f'Task {n} started')
    await asyncio.sleep(2)
    print(f'Task {n} finished')
    return n * 2
async def main():
    tasks = [task(i) for i in range(10)]
    results = await asyncio.gather(*tasks)
    print(f'Results: {results}')
if __name__ == "__main__":
    asyncio.run(main())

在这个示例中，使用了 asyncio 来并发执行任务，每个任务会在 2 秒后完成，并最终输出所有任务的结果。

四、选择合适的并发模型

选择合适的并发模型取决于任务的类型：

I/O 密集型任务（如网络请求、文件操作）：使用线程池或 asyncio。
CPU 密集型任务（如计算密集的操作）：使用进程池。

I/O 密集型任务示例

使用 requests 库进行网络请求，并使用线程池和 asyncio 分别实现并发。

使用线程池

import requests
import concurrent.futures
def fetch(url):
    response = requests.get(url)
    return response.status_code
urls = ['http://example.com' for _ in range(10)]
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(fetch, url) for url in urls]
    for future in concurrent.futures.as_completed(futures):
        print(f'Status Code: {future.result()}')

使用 asyncio 和 aiohttp

import aiohttp
import asyncio
async def fetch(session, url):
    async with session.get(url) as response:
        return response.status
async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, 'http://example.com') for _ in range(10)]
        results = await asyncio.gather(*tasks)
        print(f'Status Codes: {results}')
if __name__ == "__main__":
    asyncio.run(main())

CPU 密集型任务示例

使用 concurrent.futures.ProcessPoolExecutor 实现并发。

import concurrent.futures
import math
def compute_factorial(n):
    return math.factorial(n)
numbers = [100000] * 10
with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(compute_factorial, num) for num in numbers]
    for future in concurrent.futures.as_completed(futures):
        print(f'Factorial: {future.result()}')