几种并发模式的实现

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

• 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}")
  

  与多线程使用方式相同