1. 引言

在Python开发中，我们经常需要同时处理高并发网络请求和CPU密集型任务。这时，开发者可能会选择：

• 多线程（ThreadPoolExecutor）处理阻塞IO任务
  
• 异步IO（asyncio + aiohttp）优化高并发网络请求
  

然而，当尝试在多线程环境中运行异步代码时，可能会遇到错误：

1. ERROR - There is no current event loop in thread 'Thread-4'.

复制代码

本文将分析该问题的原因，并提供3种解决方案，包括：

• 纯同步方案（requests）
  
• 异步+多线程方案（aiohttp + asyncio.run_coroutine_threadsafe）
  
• 多进程替代方案（ProcessPoolExecutor）
  

最后，我们还会给出Java的等效实现（基于CompletableFuture和HttpClient）。

2. 问题背景


2.1 错误复现

以下代码在多线程中调用异步函数时崩溃：

1. from concurrent.futures import ThreadPoolExecutor
   
2. import asyncio
   
3. 
   
4. async def async_task():
   
5.     await asyncio.sleep(1)
   
6.     return "Done"
   
7. 
   
8. def run_in_thread():
   
9.     # 直接调用会报错：There is no current event loop in thread
   
10.     result = async_task()  # ❌ 错误！
    
11.     return result
    
12. 
    
13. with ThreadPoolExecutor() as executor:
    
14.     future = executor.submit(run_in_thread)
    
15.     print(future.result())

复制代码

2.2 原因分析

asyncio 的事件循环是线程局部的，每个线程需要自己的事件循环。
主线程默认有事件循环，但子线程没有。
直接在新线程中调用 await 会导致 RuntimeError。

3. 解决方案


3.1 方案1：纯同步实现（推荐）

如果不需要高性能异步IO，直接改用同步请求库（如requests）：

1. import requests
   
2. 
   
3. def sf_express_order_count_sync(consigneePhone, cookie, createTimeStart, createTimeEnd):
   
4.     """同步版：使用requests发送HTTP请求"""
   
5.     url = 'https://sd.sf-express.com/api/merge/order/count'
   
6.     response = requests.post(url, headers=headers, json=payload)
   
7.     return response.json()

复制代码

优点：

• 代码简单，无需处理事件循环
  
• 兼容所有Python版本
  

缺点：
性能较低（每个请求阻塞线程）

3.2 方案2：异步+多线程混合

如果必须用异步IO（如aiohttp），需为每个线程创建事件循环：

1. import aiohttp
   
2. 
   
3. async def sf_express_order_count_async(consigneePhone, cookie, createTimeStart, createTimeEnd):
   
4.     """异步版：使用aiohttp"""
   
5.     async with aiohttp.ClientSession() as session:
   
6.         async with session.post(url, headers=headers, json=payload) as resp:
   
7.             return await resp.json()
   
8. 
   
9. def run_async_in_thread(async_func, *args):
   
10.     """在子线程中运行异步函数"""
    
11.     loop = asyncio.new_event_loop()
    
12.     asyncio.set_event_loop(loop)
    
13.     try:
    
14.         return loop.run_until_complete(async_func(*args))
    
15.     finally:
    
16.         loop.close()
    
17. 
    
18. ​​​​​​​# 在线程池中调用
    
19. with ThreadPoolExecutor() as executor:
    
20.     future = executor.submit(
    
21.         run_async_in_thread,
    
22.         sf_express_order_count_async,
    
23.         "13112345678",
    
24.         "cookie123",
    
25.         1630000000
    
26.     )
    
27.     print(future.result())

复制代码

优点：

• 高性能（异步IO + 多线程）
  
• 适用于高并发场景
  

缺点：

• 代码复杂度高
  
• 需要手动管理事件循环
  

3.3 方案3：改用多进程

如果异步+多线程仍不满足需求，可用ProcessPoolExecutor替代：

1. from concurrent.futures import ProcessPoolExecutor
   
2. 
   
3. def check_phones_with_processes(phone_numbers):
   
4.     """使用进程池规避GIL和事件循环问题"""
   
5.     with ProcessPoolExecutor() as executor:
   
6.         futures = [executor.submit(has_orders, phone) for phone in phone_numbers]
   
7.         for future in as_completed(futures):
   
8.             if future.result():
   
9.                 return future.result()

复制代码

优点：

• 绕过GIL限制
  
• 每个进程有独立的事件循环
  

缺点：

• 进程启动开销大
  
• 进程间通信复杂
  

4. Java等效实现

在Java中，可以使用CompletableFuture和HttpClient实现类似功能：

1. import java.net.http.HttpClient;
   
2. import java.net.http.HttpRequest;
   
3. import java.net.http.HttpResponse;
   
4. import java.util.concurrent.CompletableFuture;
   
5. 
   
6. public class SfExpressChecker {
   
7.     private static final HttpClient httpClient = HttpClient.newHttpClient();
   
8. 
   
9.     public static CompletableFuture<Boolean> hasOrdersAsync(String phone, String cookie) {
   
10.         HttpRequest request = HttpRequest.newBuilder()
    
11.                 .uri(URI.create("https://sd.sf-express.com/api/merge/order/count"))
    
12.                 .header("Content-Type", "application/json")
    
13.                 .header("token", cookie)
    
14.                 .POST(HttpRequest.BodyPublishers.ofString(
    
15.                     String.format("{"consigneePhone":"%s"}", phone)))
    
16.                 .build();
    
17. 
    
18.         return httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    
19.                 .thenApply(response -> {
    
20.                     JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
    
21.                     return json.get("result").getAsJsonObject().get("total").getAsInt() > 0;
    
22.                 });
    
23.     }
    
24. 
    
25.     public static void main(String[] args) {
    
26.         CompletableFuture<Boolean> future = hasOrdersAsync("13112345678", "cookie123");
    
27.         future.thenAccept(hasOrders -> System.out.println("Has orders: " + hasOrders));
    
28.         future.join(); // 阻塞等待结果
    
29.     }
    
30. }

复制代码

关键点：

• Java的HttpClient原生支持异步
  
• CompletableFuture简化异步编程
  
• 无需手动管理事件循环
  

5. 总结

方案适用场景优点缺点纯同步（requests）低并发、简单场景代码简单性能差异步+多线程高并发网络请求高性能需管理事件循环多进程CPU密集型+高IO混合任务绕过GIL进程开销大最终建议：

• 优先使用同步代码（除非性能瓶颈明确）
  
• 异步+多线程适合高并发HTTP请求
  
• Java的异步方案更优雅（推荐
  1. CompletableFuture

  复制代码
  ）
  

通过合理选择方案，可以避免

1. There is no current event loop

复制代码

错误，并构建高性能的并发应用。
到此这篇关于Python解决多线程运行异步代码报错"There is no current event loop"的文章就介绍到这了,更多相关Python解决多线程运行异步报错内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/python/33970455v.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！