几种并发模式的实现

常见的几个需要并发的场景，具体的实现方式

asyncio异步并发

import asyncio

async def task(id, delay):
    await asyncio.sleep(delay)
    return f"Task {id} completed"

async def main():
    tasks = [task(1, 2), task(2, 1), task(3, 3)]
    done, pending = await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)
    for completed_task  in done:
        try:
            result = await completed_task
            print(result)
        except Exception as e:
            print(f"An error occurred: {e}")

asyncio.run(main())

#返回结果：Task 2 completed  Task 3 completed  Task 1 completed

注意点
若只想运行任务而不需要返回结果，不阻塞程序，则可以直接asyncio.create_task(），只创建完任务便可。后续若再想要结果，则再查看这个任务的返回结果便可。
与其相关的无论是异步函数，还是常规函数，还是第三方库里面的函数。全部不能用time.sleep()这种阻塞,只能使用异步的sleep。因此要详细查看相关函数，是否有这种调用。

Thread多线程并发

from concurrent.futures import ThreadPoolExecutor,as_completed,wait
import time

def task(n):
    print(f"开始执行任务 {n}")
    if n == 0:
        time.sleep(2.5)
    else:
        time.sleep(n)
    print(f"任务 {n} 执行完毕")
    return n * n

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(task, i) for i in range(5)]

    # 方式一：按照“提交顺序”获取排列的Future对象
    # for future in futures:
    #     result = future.result()
    #     print(f"任务结果：{result}")
    
    # 方式二：使用as_completed,按照“完成顺序”获取排列的Future对象，实时返回
    # for future in as_completed(futures):
    #     result = future.result()
    #     print(f"任务结果：{result}")
        
    # 方式三：等待所有任务都完成后，返回结果，无顺序
    done, not_done = wait(futures)
    for future in done:
        result = future.result()
        print(f"任务结果：{result}")
方式一结果：
开始执行任务 0
开始执行任务 1
开始执行任务 2
开始执行任务 3
开始执行任务 4
任务 1 执行完毕
任务 2 执行完毕
任务 0 执行完毕
任务结果：0
任务结果：1
任务结果：4
任务 3 执行完毕
任务结果：9
任务 4 执行完毕
任务结果：16

方式二结果：
开始执行任务 0
开始执行任务 1
开始执行任务 2
开始执行任务 3
开始执行任务 4
任务 1 执行完毕
任务结果：1
任务 2 执行完毕
任务结果：4
任务 0 执行完毕
任务结果：0
任务 3 执行完毕
任务结果：9
任务 4 执行完毕
任务结果：16

方式三结果：
开始执行任务 0
开始执行任务 1
开始执行任务 2
开始执行任务 3
开始执行任务 4
任务 1 执行完毕
任务 2 执行完毕
任务 0 执行完毕
任务 3 执行完毕
任务 4 执行完毕
任务结果：1
任务结果：9
任务结果：4
任务结果：0
任务结果：16

multiprocessing多进程并发

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor,as_completed,wait
import time

def task(n):
    print(f"开始执行任务 {n}")
    if n == 0:
        time.sleep(2.5)
    else:
        time.sleep(n)
    print(f"任务 {n} 执行完毕")
    return n * n
if __name__ == '__main__':
    # with ThreadPoolExecutor(max_workers=5) as executor:
    executor = ProcessPoolExecutor(max_workers=5)
    futures = [executor.submit(task, i) for i in range(5)]

    # 方式一：按照“提交顺序”获取排列的Future对象
    # for future in futures:
    #     result = future.result()
    #     print(f"任务结果：{result}")