[已解决]async 同步计时问题。。。

abababab

1.             async def my_event_handler(event):
   
2.                 global t_result
   
3.                 global stop_condition
   
4.                 stop_condition = True
   
5.                 ply = event.text
   
6.                 t_result={as:ply}
   
7.                 await client.disconnect()
   
8.                 return stop_condition,t_result                    
   
9. 
   
10.             async def timer():
    
11.                 # 计时器代码
    
12.                 global t_result
    
13.                 global stop_condition
    
14.                 time.sleep(5)
    
15.                 stop_condition = False
    
16.                 print("timer Exception")
    
17.                 client.disconnect()
    
18.                 t_result={as:"超时，请稍后重试！"}
    
19.                 return stop_condition,t_result
    
20. 
    
21. 
    
22.             with client:
    
23.                 client.run_until_disconnected()
    
24.             return stop_condition,t_result

复制代码

想加个async 同步计时， 超过5秒程序就直接返回超时，但现在加了async def timer(): 没效果，请大佬帮看下，感谢！

最佳答案

月排行榜 / 总排行榜

sfqxx

2023-5-8 17:55:03

根据你提供的代码，`timer()`函数似乎并没有被调用。为了使用异步计时器，你可以使用`asyncio.sleep()`函数。这里是一个可能会起作用的修改版本：

1. 
   
2. import asyncio
   
3. 
   
4. async def my_event_handler(event):
   
5.     global t_result
   
6.     global stop_condition
   
7.     stop_condition = True
   
8.     ply = event.text
   
9.     t_result={as:ply}
   
10.     await client.disconnect()
    
11.     return stop_condition, t_result                    
    
12. 
    
13. async def timer():
    
14.     # 计时器代码
    
15.     global t_result
    
16.     global stop_condition
    
17.     await asyncio.sleep(5)  # 使用asyncio.sleep()实现计时
    
18.     stop_condition = False
    
19.     print("timer Exception")
    
20.     await client.disconnect()
    
21.     t_result={as:"超时，请稍后重试！"}
    
22.     return stop_condition,t_result
    
23. 
    
24. 
    
25. with client:
    
26.     asyncio.ensure_future(timer())  # 启动计时器的运行
    
27.     client.run_until_disconnected()
    
28. 
    
29. return stop_condition,t_result

复制代码

在上面的代码中，将计时器函数与事件处理程序串联起来，然后通过`asyncio.ensure_future()`函数启动计时器。这应该会在事件处理程序与计时器之间创建一个协程链，使其同时运行，并且在事件处理程序返回结果或者计时器完成时结束。
有用请设置最佳答案

跳转到最佳答案楼层

isdkz

你可以使用 asyncio.sleep() 方法来实现异步计时器。下面是修改后的代码：

1. import asyncio
   
2. 
   
3. async def my_event_handler(event):
   
4.     global t_result
   
5.     global stop_condition
   
6.     stop_condition = True
   
7.     ply = event.text
   
8.     t_result = {as:ply}
   
9.     await client.disconnect()
   
10.     return stop_condition, t_result                    
    
11. 
    
12. async def timer():
    
13.     # 计时器代码
    
14.     global t_result
    
15.     global stop_condition
    
16.     await asyncio.sleep(5)
    
17.     stop_condition = False
    
18.     print("timer Exception")
    
19.     await client.disconnect()
    
20.     t_result = {as:"超时，请稍后重试！"}
    
21.     return stop_condition, t_result
    
22. 
    
23. loop = asyncio.get_event_loop()
    
24. tasks = [loop.create_task(my_event_handler(event)), loop.create_task(timer())]
    
25. done, pending = loop.run_until_complete(asyncio.wait(tasks, timeout=5))
    
26. if len(done) == 0:
    
27.     # 超时处理
    
28.     stop_condition = False
    
29.     t_result = {as:"超时，请稍后重试！"}
    
30. else:
    
31.     # 处理结果
    
32.     for task in done:
    
33.         stop_condition, t_result = task.result()
    
34. 
    
35. loop.close()
    
36. return stop_condition, t_result
    

复制代码

这里使用 asyncio.wait() 方法来同时等待事件处理和计时器任务的完成，设置超时时间为 5 秒。如果在超时时间内没有完成任务，则返回超时提示。如果完成了任务，则返回任务的结果。

sfqxx

根据你提供的代码，`timer()`函数似乎并没有被调用。为了使用异步计时器，你可以使用`asyncio.sleep()`函数。这里是一个可能会起作用的修改版本：

1. 
   
2. import asyncio
   
3. 
   
4. async def my_event_handler(event):
   
5.     global t_result
   
6.     global stop_condition
   
7.     stop_condition = True
   
8.     ply = event.text
   
9.     t_result={as:ply}
   
10.     await client.disconnect()
    
11.     return stop_condition, t_result                    
    
12. 
    
13. async def timer():
    
14.     # 计时器代码
    
15.     global t_result
    
16.     global stop_condition
    
17.     await asyncio.sleep(5)  # 使用asyncio.sleep()实现计时
    
18.     stop_condition = False
    
19.     print("timer Exception")
    
20.     await client.disconnect()
    
21.     t_result={as:"超时，请稍后重试！"}
    
22.     return stop_condition,t_result
    
23. 
    
24. 
    
25. with client:
    
26.     asyncio.ensure_future(timer())  # 启动计时器的运行
    
27.     client.run_until_disconnected()
    
28. 
    
29. return stop_condition,t_result

复制代码

在上面的代码中，将计时器函数与事件处理程序串联起来，然后通过`asyncio.ensure_future()`函数启动计时器。这应该会在事件处理程序与计时器之间创建一个协程链，使其同时运行，并且在事件处理程序返回结果或者计时器完成时结束。
有用请设置最佳答案