asyncio动态添加协程 关闭协程

最新推荐文章于 2025-07-04 15:00:33 发布
原创 最新推荐文章于 2025-07-04 15:00:33 发布 · 3.4k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#动态协程 #asyncio #关闭协程

本文介绍了如何在Python的asyncio库中动态添加协程并关闭另一个线程的事件循环。通过创建线程并在其中运行新的事件循环，可以利用`run_coroutine_threadsafe`来安全地执行协程。同时，文章讨论了每个线程默认的select循环以及如何管理这些循环。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

其实简单的不得了.  弄个线程,在线程里运行一个新的事件循环. 然后调用 run_coroutine_threadsafe 即可. 

asyncio基础 : python 异步 asyncio

asyncio.get_event_loop() 默认是主线程的事件循环

每个线程一个事件循环 , 默认情况select循环

下面给出实现:

mport asyncio

#线程
def thread_running_loop(lp:asyncio.AbstractEventLoop):
    print('loop running')
    asyncio.set_event_loop(lp)    #在此线程中设置一个新的事件循环,默认情况下事件循环是主线程的
    lp.run_forever()              #一直运行


#随意的一个协程
async def xxx(arg):
    print('ready to work arg:' , arg)
    await  asyncio.sleep(1)
    print('done ', arg)



#创建一个新的事件循环给子线程
newlp = asyncio.new_event_loop()
t = threading.Thread(target=thread_running_loop,args=(newlp,))
t.start()


#添加5个协程. 并指定事件循环 (第2个参数)
for i in range(5):
    asyncio.run_coroutine_threadsafe(xxx(i),newlp)

t.join()

 

关闭 另一个线程的事件循环:


                

        

    

    
  


        

            

                      
                        最低0.47元/天 解锁文章
                        

                          
200万优质内容无限畅学

                          
                        

                      
            

        


    



                



	

		

			

				
					
Python通过协程实现异步爬虫--asyncio技巧

				
			

			

				

					景天科技苑
				

				

					12-29
					
					4659
					
				

			

		

		

			
				
很多同学对于异步这个概念只是停留在了“听说很NB”的认知层面上，很少有人能够在项目中真正的使用异步实现高性能的相关操作。接下来，咱们就一起来学习一下，爬虫中如何使用异步实现高性能的数据爬取操作。

			
		

	



                

            
              



	

		

			

				
					
Python协程(asyncio)（一）协程开发

				
			

			

				

					
				

				

					09-21
					
					650
					
				

			

		

		

			
				
协程是python个中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元（理解为需要的资源）。为啥说它是一个执行单元，因为它自带CPU上下文。这样只要在合适的时机， 我们可以把一个协程 切换到另一个协程。只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的。通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定。

			
		

	



              


  
              

                


	

		

			

				
					
python动态加载脚本_python协程之动态添加任务的方法

				
			

			

				

					weixin_39631667的博客
				

				

					12-10
					
					315
					
				

			

		

		

			
				
python协程只能运行在事件循环中，但是一旦事件循环运行，又会阻塞当前任务。所以只能在当前进程中再开一个线程，这个线程的主要任务是运行事件循环，就是event_loop,因为他是一个无限循环，会阻塞当前线程。放一个自己写的demo，注释写的很详细。另外还有一点需要注意，一个事件循环中不能运行另外一个事件循环。运行结果：import asynciofrom threading ...

			
		

	





	

		

			

				
					
asyncio cancel取消协程

				
			

			

				

					迷心兔的博客
				

				

					10-09
					
					1875
					
				

			

		

		

			
				
# coding=utf-8

import asyncio
import time


# 协程中是不能使用同步阻塞编程的
async def get_html (url):
    print('start get url', url)
    await asyncio.sleep(2)
    print('end get url')


async def get_html2 (url)...

			
		

	



		

			
		



	

		

			

				
					
解决使用asyncio.run_coroutine_threadsafe，获取result()超时卡死问题

				
			

			

				

					Rysxt_的博客
				

				

					07-04
					
					410
					
				

			

		

		

			
				
检测是否是当前事件循环中又创建事件循环导致的堵塞，如果提交的协程是在当前的事件循环就会导致阻塞现象原始问题代码。

			
		

	





	

		

			

				
					
asyncio.run 会close当前的event_loop

				
			

			

				

					聆听风雨的博客
				

				

					09-03
					
					701
					
				

			

		

		

			
				
asyncio.run执行完之后会终结异步生成器，并关闭线程池。不要再asyncio.run之后调用asynio.get_event_loop()

			
		

	





	

		

			

				
					
python 协程 asyncio_Python asyncio：当一个协程是don时停止循环

				
			

			

				

					weixin_29328371的博客
				

				

					03-01
					
					364
					
				

			

		

		

			
				
对于python异步主题，我还是个新手。我有一个简单的问题：我有一个包含两个协同程序的任务要同时运行。第一个协同程序(my_-co-routine)只会连续打印一些内容，直到达到第二个“从”到“第二个”睡眠。第二个协同程序(seq_-coroutine)将依次调用4个其他协同程序。我的目标是在seq氶co routine结束时停止循环，只要它完全完成。确切地说，我希望我的协同程序在seq\u协同程...

			
		

	





	

		

			

				
					
asyncio合并基础到动态协程

				
			

			

				

					迷心兔的博客
				

				

					11-15
					
					885
					
				

			

		

		

			
				
import time
import asyncio
import logging
import functools
import nest_asyncio
nest_asyncio.apply() # 需要这个，不然asyncio运行出错
from threading import Thread
logging.basicConfig( # 用日志打印输出信息
    level=logging...

			
		

	





	

		

			

				
					
Python Asyncio 所有异步协程库用法详解

				
			

			

				

					浪子燕青的博客
				

				

					02-24
					
					2331
					
				

			

		

		

			
				
title: Asyncio并发编程
copyright: true
top: 0
date: 2019-04-03 14:09:24
tags: Asyncio
categories: Python高阶笔记
permalink:
password:
keywords:
description: Python高并发框架，进一步解读asyncio的语法与功能，同时对支持异步的web网络请求包aiohttp功能做介绍。
我喜欢铁路，你沿着铁路走，在尽头肯定会找到一座城市，或者其他什么有人的地方。不像鸟飞在空中.

			
		

	





	

		

			

				
					
以定时器为例研究一手 Python asyncio 的协程事件循环调度

				
			

			

				

					菜皮日记
				

				

					08-14
					
					752
					
				

			

		

		

			
				
asyncio 中的定时通过实现，原理是在事件循环中维护一个最小堆实现的优先队列_scheduled，其中保存的都是定时任务处理对象Handle，越早到期Handle就会越早被取出来并加入到队列，在下一轮循环时取出并从挂起的位置恢复执行。由于协程代码在执行时会切换控制权导致代码逻辑跳来跳去，有时会被绕晕，借助定时器的调度可以让整个事件循环的逻辑更加清晰。

			
		

	





	

		

			

				
					
python异步编程案例之协程执行和停止

				
			

			

				

					HighDS的博客
				

				

					01-30
					
					1万+
					
				

			

		

		

			
				
loop启动之后，ctrl+c，run_until_complete的执行异常。通过asyncio.Task可以取消future。
import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
    print("Hello:", x)
    time.sleep(1)
    return "w...

			
		

	





	

		

			

				
					
asyncio 系列五、asyncio的事件循环

				
			

			

				

					duxin_csdn的博客
				

				

					05-24
					
					8676
					
				

			

		

		

			
				
官网连接：https://docs.python.org/zh-cn/3.7/library/asyncio-eventloop.html#asyncio.loop.run_in_executor



事件循环是每个 asyncio 应用的核心。 事件循环会运行异步任务和回调，执行网络 IO 操作，以及运行子进程。里面封装的方法用于上层函数调用。本节所针对的主要是低层级代码、库和框架的编写者，...

			
		

	





	

		

			

				
					
asyncio多线程操作:run_coroutine_threadsafe(coro, loop)

				
			

			

				

					weixin_62077901的博客
				

				

					08-18
					
					6142
					
				

			

		

		

			
				
asyncio多线程操作:run_coroutine_threadsafe(coro, loop)

			
		

	





	

		

			

				
					
RPC框架编写实践——服务治理的基石

				
			

			

				

					公众号：该用户快成仙了
				

				

					08-25
					
					224
					
				

			

		

		

			
				
前言

由于服务的调用是通过网络间来调用了， 服务并不在同一个进程内， 程序可能崩溃、节点可能宕机、网络可能中断，这些意外情况其实全部都在意料之中, 微服务的一个思想就是， 所有假设会出错的东西一定会出现， 而且没办法完全避免， 只能通过一些功能去增加容错性， 稳定性和可用性， 这类功能被统称为服务治理， 大部分功能都会利用过去一段时间产生的数据来决策接下来的请求该怎么做， 而这些数据就是服务治理的基石。

1.指标数据

在服务治理中的一些常见功能如限流、 负载均衡、 熔断器、监控统计等等都需要一些指标数

			
		

	





	

		

			

				
					
Python asyncio文档翻译--运行一个消息循环EventLoop

				
			

			

				

					zoe9698的博客
				

				

					07-04
					
					2107
					
				

			

		

		

			
				
AbstractEventLoop.run_forever()
轮询I/O选择器直到遇到一个“0”超时，调用所有已排程的回调函数以响应I/O事件（以及那些已经排程的），然后退出。如果stop（）在run_forever时，就会运行当下的一批回调函数然后退出。注意回调函数被回调函数排程不会运行，他们会在下一次run_forever时被调用。


在3.5.1版本发生改变


Abstr

			
		

	





	

		

			

				
					
python asyncio 异常处理_python3 asyncio官方文档中文版

				
			

			

				

					weixin_39672160的博客
				

				

					12-06
					
					997
					
				

			

		

		

			
				
事件循环基类事件循环基类事件循环是由asyncio提供的核心执行装置。它提供了多种服务，包括：注册、执行和关闭延时调用(超时)为各种通信创建客户端和服务端传输为一个外部程序通信启动子进程和相关的传输把高成本的函数调用委托到线程池class asyncio.BaseEventLoop此类是一个实现细节。此类是AbstractEventLoop的子类，是你在asyncio中找到的具体事件循环类的基类。...

			
		

	





	

		

			

				
					
Python 异步: 什么是事件循环 ?（6）

				
			

			

				

					冷冻工厂
				

				

					02-03
					
					1366
					
				

			

		

		

			
				
asyncio 程序的核心是事件循环。在本节中，我们将花点时间看一下 asyncio 事件循环。
1. 什么是 Asyncio 事件循环
事件循环是用于在单个线程中执行协程的环境。事件循环是异步程序的核心。
它做了很多事情，例如：

执行协程。执行回调。执行网络输入/输出。运行子进程。
事件循环是一种常见的设计模式，并且由于在 JavaScript 中的使用而在最近变得非常流行。
事件循环，顾名思义，就是一个循环。它管理一个任务列表（协同程序）并尝试在循环的每次迭代中按顺序推进每个任务，以及执行其他任务，如

			
		

	





	

		

			

				
					
python asyncio 一些函数

				
			

			

				

					weixin_43938663的博客
				

				

					07-24
					
					328
					
				

			

		

		

			
				
async def 用来定义异步函数，其内部有异步操作。每个线程有一个事件循环，主线程调用asyncio.get_event_loop()时会创建事件循环，你需要把异步的任务丢给这个循环的run_until_complete()方法，事件循环会安排协同程序的执行。
await 关键字加在需要等待的操作前面。
如果我们需要请求多个URL该怎么办呢，同步的做法访问多个URL只需要加个for循环就可以了。但异步的实现方式并没那么容易，在之前的基础上需要将hello()包装在asyncio的Future对象中，然.

			
		

	





	

		

			

				
					
python异步asyncio函数多线程操作run_in_executor和run_coroutine_threadsafe解析

					
热门推荐

				
			

			

				

					hellojike的博客
				

				

					03-22
					
					1万+
					
				

			

		

		

			
				
刚接触异步asyncio，发现python文档一个版本一个变化，恼火。
东拼西凑终于解决了asyncio的多线程操作，记录下来。对于一个门外汉。太难了。
首先python3.9版本终于封装了一个多线程函数
asyncio.to_thread(func, /, *args, **kwargs) #函数直接开线程，传递参数。感觉这才像python

目前3.9以下看来，asyncio多线程实现就是，两个函数：
run_in_executor 和 run_coroutine_threadsafe

对应两种需求。

			
		

	





	

		

			

				
					
asyncio.run使用时主协程得等待新协程运行完才会继续执行，如何解决

					
最新发布

				
			

			

				

					08-03
				

			

		

		

			
				
<think>我们正在讨论Python的asyncio模块，特别是关于在asyncio.run中主协程等待子协程完成的问题。根据引用，我们知道asyncio.run是用于运行一个协程并等待其完成的，它通常作为程序的入口点。然而，用户的问题是关于主协程（即被asyncio.run运行的协程）如何等待它内部创建的子协程完成。

 根据引用[3]和[4]，我们可以知道，在异步编程中，当我们使用`await`关键字来调用一个协程时，当前协程会挂起直到被调用的协程完成。但是，如果我们想要同时运行多个协程（即并发执行），我们不应该使用`await`一个一个地等待，因为那样会顺序执行。相反，我们应该使用`asyncio.create_task`来将协程包装成任务，然后使用`await`来等待这些任务完成。

 在用户的问题中，他提到“主协程需要等待新协程完成”，这实际上是asyncio的默认行为：如果你使用`await`来等待一个协程，那么当前协程会等待直到那个协程完成。但是，如果主协程创建了多个任务，并且希望等待所有这些任务完成（即使它们是并发的），我们可以使用`asyncio.gather`或`asyncio.wait`。

 然而，用户可能遇到了这样的问题：在`asyncio.run(main())`中，`main`协程内部创建了一些子协程（任务），但主协程（main）在退出时，如果还有未完成的任务，那么这些任务会被取消。因此，我们需要确保主协程等待所有子任务完成后再退出。

 解决方法：
 1. 使用`asyncio.create_task`创建任务，这样它们会在事件循环中并发运行。
 2. 在主协程中，使用`await`来等待所有任务完成。可以使用`asyncio.gather`来收集多个任务并等待它们完成。

 例如，假设我们有一个主协程`main`，它要并发执行两个子协程`task1`和`task2`，我们可以这样做：

 ```python
 import asyncio

 async def task1():
     await asyncio.sleep(1)
     print("Task 1 done")

 async def task2():
     await asyncio.sleep(2)
     print("Task 2 done")

 async def main():
     # 创建任务并启动
     t1 = asyncio.create_task(task1())
     t2 = asyncio.create_task(task2())

     # 等待两个任务都完成
     await asyncio.gather(t1, t2)
     print("All tasks done")

 asyncio.run(main())
 ```

 这样，主协程`main`会等待`task1`和`task2`都完成后才退出。然后`asyncio.run`会关闭事件循环。

 但是，用户可能遇到了嵌套使用`asyncio.run`的问题。根据引用[2]，在同一个线程中，我们不能嵌套调用`asyncio.run`，因为每次调用`asyncio.run`都会创建一个新的事件循环并关闭旧的事件循环。因此，在已经运行的事件循环中再调用`asyncio.run`会导致错误。

 所以，如果用户想要在主协程中运行另一个协程，不应该再使用`asyncio.run`，而是应该使用`await`或者`asyncio.create_task`。

 总结：
 1. 在同一个线程中，避免嵌套调用`asyncio.run`。
 2. 使用`asyncio.create_task`创建任务，然后使用`await asyncio.gather`来等待所有任务完成。

 因此，针对用户的问题，解决方法就是：在主协程中，将需要并发执行的子协程封装为任务，然后使用`asyncio.gather`或类似方法等待它们完成。

 注意：如果用户希望在主协程中启动一些后台任务，并且不想等待它们完成（即主协程先退出，但后台任务继续运行），这是不允许的。因为当主协程退出时，事件循环会被关闭，所有未完成的任务都会被取消。所以，一定要确保在主协程退出前，所有任务都已经完成。

 如果用户希望主协程在启动任务后，能够处理其他事情，并在最后等待任务完成，那么可以将任务的创建和等待分开。例如：

 ```python
 async def main():
     task1 = asyncio.create_task(long_task1())
     task2 = asyncio.create_task(long_task2())

     # 在等待任务完成之前，可以做一些其他事情
     await asyncio.sleep(0.5)
     print("Doing something else...")

     # 然后等待任务完成
     await task1
     await task2
 ```

 或者使用`asyncio.gather`一次性等待多个任务。

 因此，用户的问题的解决方法是：避免嵌套`asyncio.run`，使用`asyncio.create_task`和`asyncio.gather`来管理并发任务并等待它们完成。</think>### asyncio.run 主协程等待子协程完成的解决方法

在 Python 的异步编程中，`asyncio.run()` 会等待**主协程**完成，但不会自动等待主协程内部创建的**子协程**完成。以下是原因分析和解决方法：

#### 问题原因
1. **任务生命周期**：`asyncio.run()` 只保证主协程（入口函数）执行完成，不等待其创建的未完成子任务[^1][^3]。
2. **事件循环关闭**：当主协程返回时，事件循环会立即关闭，所有未完成的子任务会被取消[^3][^4]。
3. **显式等待需求**：子协程需要显式等待（`await`）或封装为任务（`Task`）并通过特定机制管理[^3][^5]。

---
### 解决方案

#### 方法 1：使用 `asyncio.gather()` 等待所有子任务
```python
import asyncio

async def sub_task():
    await asyncio.sleep(1)
    print("子任务完成")

async def main():
    # 创建并等待所有子任务
    await asyncio.gather(
        sub_task(),
        sub_task(),
        sub_task()
    )
    print("主协程完成")

asyncio.run(main())
```
**效果**：
- 主协程会等待所有 `gather()` 中的子任务完成
- 所有任务并发执行，总耗时 ≈ 1秒（而非顺序执行的3秒）

#### 方法 2：手动管理任务对象
```python
async def main():
    tasks = [
        asyncio.create_task(sub_task()),
        asyncio.create_task(sub_task())
    ]
    # 显式等待所有任务完成
    await asyncio.wait(tasks)
    print("主协程完成")
```
**优势**：更灵活的任务控制（如添加超时、单独取消等）。

#### 方法 3：嵌套 `await`（顺序执行）
```python
async def main():
    await sub_task()  # 等待子任务1完成
    await sub_task()  # 再执行子任务2
```
**注意**：此方法导致任务**顺序执行**，失去并发优势[^3][^5]。

---
### 关键原则
1. **任务封装**：子协程需通过 `asyncio.create_task()` 或 `asyncio.gather()` 转为任务[^3][^4]。
2. **显式等待**：主协程必须显式 `await` 任务集合[^5]。
3. **避免嵌套事件循环**：禁止在 `asyncio.run()` 内部再调用 `asyncio.run()`（会导致 `RuntimeError`）[^2][^4]。

> 通过 `asyncio.gather()` 或 `asyncio.wait()` 管理子任务，可确保主协程等待所有子任务完成后再退出，避免任务被意外取消[^3][^4]。

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值