asyncio -如何在不停止事件循环的情况下停止(和重新启动)服务器？
在使用asyncio构建服务器时，可以通过以下步骤在不停止事件循环的情况下停止和重新启动服务器：
- 创建一个全局变量
server，用于保存服务器对象。 - 使用
asyncio.create_server()函数创建服务器，并将其赋值给server变量。 - 在事件循环中使用
asyncio.ensure_future()函数将服务器对象加入任务队列。 - 当需要停止服务器时，调用
server.close()方法关闭服务器的监听端口。 - 调用
await server.wait_closed()等待服务器完全关闭。 - 如果需要重新启动服务器，可以再次调用
asyncio.create_server()函数创建新的服务器对象，并将其赋值给server变量。 - 重新启动服务器后，再次将服务器对象加入任务队列。
下面是一个示例代码：
import asyncio
async def handle_client(reader, writer):
# 处理客户端请求的逻辑
pass
async def main():
global server
server = await asyncio.create_server(handle_client, 'localhost', 8888)
asyncio.ensure_future(server.serve_forever())
# 服务器运行中...
# 停止服务器
server.close()
await server.wait_closed()
# 重新启动服务器
server = await asyncio.create_server(handle_client, 'localhost', 8888)
asyncio.ensure_future(server.serve_forever())
# 服务器重新启动中...
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(main())在上述示例中，handle_client()函数用于处理客户端请求的逻辑。main()函数是主函数，其中通过asyncio.create_server()函数创建服务器对象，并使用asyncio.ensure_future()函数将服务器对象加入任务队列。在停止服务器时，调用server.close()方法关闭服务器的监听端口，并使用await server.wait_closed()等待服务器完全关闭。在重新启动服务器时，再次调用asyncio.create_server()函数创建新的服务器对象，并将其赋值给server变量。
请注意，以上示例中的IP地址和端口号仅作为示例，实际应根据需求进行修改。
推荐的腾讯云相关产品：腾讯云云服务器（CVM）和腾讯云容器服务（TKE）。
相关·内容
import signal
import asyncio
from typing import Optional
from types import FrameType
async def main() -> None:
server = (
await asyncio.start_server(
lambda reader, writer: None,
'127.0.0.1',
7070
)
)
tasks = (
asyn
浏览 6提问于2022-10-23得票数 2
1回答
我正在尝试使用异步和线程一起处理一个不和谐的机器人。我找到了脚本，并根据自己的需要进行了修改：
import time
import threading as th
import asyncio
import discord
class discordvars(object):
client=discord.Client()
TOKEN=('---')
running_discordthread=False
discordloop = asyncio.get_event_loop()
discordloop.create_task(c
浏览 5提问于2020-10-22得票数 0
1回答
关闭/关闭
、、
我扩展了websocket回送服务器示例()，使其嵌入到Tkinter应用程序中。当按下“开始”按钮时，服务器将启动。现在，我想停止服务器时，按下“停止”按钮。然而，close()不起作用。
server.py
try:
import Tkinter as Tk
from Tkinter import ttk
except ModuleNotFoundError:
import tkinter as Tk
from tkinter import ttk
import asyncio
import websockets
class TkEcho():
浏览 3提问于2020-07-22得票数 0
回答已采纳
在Python 中，它声明：
应用程序开发人员通常应该使用高级异步函数(如asyncio.run() )，并且很少需要引用循环对象或调用其方法。本节主要针对低级别代码、库和框架的作者，他们需要对事件循环行为进行更精细的控制。
当同时使用async和threadpoolexecutor时，如示例代码所示(来自文档)：
import asyncio
import concurrent.futures
def blocking_io():
# File operations (such as logging) can block the
# event loop: run
浏览 4提问于2019-12-05得票数 9
回答已采纳
1回答
我想用zmq套接字创建一个tcp服务器。下面的代码使用python的异步ioloop使用zmq套接字创建tcp服务器。
在下面的代码中，我创建了zmq套接字来侦听传入的连接。coroutine recv_and_process创建一个套接字来侦听连接，并有一个while循环来响应传入的连接。
我的问题是如何消除while循环，而使用存在的asyncio event loop？
import asyncio
import zmq
import zmq.asyncio
zmq.asyncio.install()
ctx = zmq.asyncio.Context()
@asyncio.coro
浏览 5提问于2017-12-24得票数 0
回答已采纳
我在Ubuntu上使用PythonWebSockets4.0.1。我想有两个websocket服务器运行。我能够通过为每个线程创建2个线程和独立的事件循环来实现“某种工作”。所谓“工作”，我指的是两种websockets的工作和响应大约30秒，然后其中一个停止。我必须重新启动这个过程才能让他们两个人重新开始工作。如果我只运行这两个线程中的一个或另一个，那么单个websocket将永远工作。
我做错了什么，如何让两个websockets永远使用异步操作？
# Start VL WebSocket Task
class vlWebSocketTask (threading.Thread):
浏览 1提问于2018-02-16得票数 5
回答已采纳
3回答
在木星笔记本中运行“旋风”服务器
、、、、
采用标准的旋风演示并将IOLoop推入后台线程，可以在单个脚本中查询服务器。当旋风服务器是一个交互式对象时，这是非常有用的(请参阅Dask或类似文件)。
import asyncio
import requests
import tornado.ioloop
import tornado.web
from concurrent.futures import ThreadPoolExecutor
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, wo
浏览 0提问于2019-03-16得票数 8
回答已采纳
1回答
我想把异步和pytest结合起来。
以下是我想做的事：
在测试运行时运行服务器--在服务器完成时停止运行。
在一个完美的世界中，我将服务器实现为一个固定的(使用产量)
我喜欢这样编写测试代码：
def test_add(svr_fixture):
await asyncio.sleep(100)
assert m.add(1, 2) == 3 # I like the readability of this and want to restore it
我试图用pytest-asyncio ()编写这个夹具，但是我想不出如何做到这一点。
我想出的这个测试(虽
浏览 5提问于2018-01-16得票数 3
回答已采纳
我使用异步作为网络框架。
在下面的代码中(low_level是我们的低级函数，main块是我们的程序条目，user_func是用户定义的函数)：
import asyncio
loop = asyncio.get_event_loop()
""":type :asyncio.AbstractEventLoop"""
def low_level():
yield from asyncio.sleep(2)
def user_func():
yield from low_level()
if __name__ == &#
浏览 3提问于2014-08-14得票数 14
1回答
我以前在Python中玩过线程处理，但决定尝试一下asyncio模块，特别是因为您可以取消运行中的任务，这似乎是一个很好的细节。然而，出于某种原因，我不能把我的头围绕在它上面。
下面是我想要实现的东西(如果我使用的术语不正确，很抱歉)：
一个downloader线程，它每x秒下载一次相同的文件，检查它的散列是否与上一次下载相同，如果它不一样的话保存它。
在后台运行的webserver线程，允许对downloader线程进行控制(暂停、列表、停止)。
我使用aiohttp作为the服务器。
到目前为止，这就是我所拥有的：
class aiotest():
def __i
浏览 2提问于2016-03-19得票数 4
回答已采纳
在本例中，我使用的是websockets模块。典型的服务器实现是这样的：
import websockets
start_server = websockets.serve(counter, "localhost", 6789)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
但是，我希望能够在不停止事件循环的情况下停止和重新启动服务器。从我看到的关于异步服务器的最小文档中，我并不清楚如何做到这一点。我也不知道websocket
浏览 32提问于2020-06-05得票数 3
回答已采纳
我对异步编程很陌生。我已经使用python3.5异步几天了。我想让服务器能够从websocket机器客户端(GPS)接收数据，并将html页面呈现为websocket服务器的浏览器客户端。我在8765端口上使用websockets连接我的机器客户端和服务器。在呈现网页时，我在端口8888 ( html文件位于./view/index.html )上使用了龙卷风。该代码仅适用于websocket服务器。当我添加龙卷风服务器时，代码表现得很奇怪，我不知道为什么。一定有异步用法。如果我把
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.
浏览 2提问于2016-02-23得票数 1
回答已采纳
我一直试图在没有运气的情况下创建一个无休止的客户端实例链。
我正在开发一个异步应用程序，这个应用程序包括许多东西，比如使用loop.create_server()运行服务器，每10秒就需要连接到服务器列表，发送一些数据，然后断开连接。
我一直收到两个错误："runtimeError: Event循环正在运行。“或者“异步>任务已被销毁，但它正在等待！”
下面的代码起作用。
import asyncio
from tcp.client import Client
def send_to_peers(data):
for index in range(1, 3): #th
浏览 0提问于2018-06-10得票数 1
回答已采纳
1回答
为什么此异步代码不停止？
、、、
下面的代码片段有两个协程，分别用于服务器和客户端。客户端协程有一个在10秒后中断while循环的逻辑，而服务器应该在15秒后停止。
当我运行脚本时，它不会停止，理想情况下，它应该在15秒后停止，但这并没有发生。
import asyncio
import time
import zmq
import zmq.asyncio
zmq.asyncio.install()
ctx = zmq.asyncio.Context()
server_socket = ctx.socket(zmq.REP)
client_socket = ctx.socket(zmq.REQ)
server_soc
浏览 22提问于2017-12-29得票数 0
回答已采纳
1回答
假设我有一个这样的web服务器： from fastapi import FastAPI
import uvicorn
import asyncio
app = FastAPI()
def blocking_function():
import time
time.sleep(5)
return 42
@app.get("/")
async def root():
loop = asyncio.get_running_loop()
result = await loop.run_in_executor(None, blockin
浏览 22提问于2020-10-27得票数 5
回答已采纳
有折页码的：
import asyncio
async def mycoro(number: int):
print(f"Starting {number}")
await asyncio.sleep(1)
print(f"Finishing {number}")
return str(number)
c = mycoro(7)
# task = asyncio.ensure_future(c)
task = asyncio.create_task(c)
loop = asyncio.get_event_loop()
loo
浏览 3提问于2021-03-09得票数 0
如果我在python3解释器上运行这个程序：
import asyncio
@asyncio.coroutine
def wait(n):
asyncio.sleep(n)
loop = asyncio.get_event_loop()
fut = asyncio.async(wait(10))
fut.add_done_callback(lambda x: print('Done'))
asyncio.Task.all_tasks()
我得到以下结果：
{<Task pending coro=<coro() running at /usr/local
浏览 3提问于2015-08-08得票数 5
回答已采纳
1回答
我不明白为什么server.py版本1允许客户机被键盘中断并重新启动，而server.py版本2不允许：
server.py Version1：
import asyncio
async def handle_client(reader, writer):
while True:
request = (await reader.read(128)).decode()
writer.write('Received ok.'.encode())
await writer.drain()
async def main():
浏览 0提问于2018-06-05得票数 1
回答已采纳
我一直在尝试使用aiohttp中的连接池，但没有成功。用例是代码重复地向几个服务器发出请求，我不想在每次请求时重新创建连接。以下是重现该问题的一些代码(错误为Timeout context manager should be used inside a task)： import asyncio
import logging
from asyncio import Future
from typing import Dict, List
from aiohttp import ClientTimeout, ClientSession, TCPConnector
class UrlSer
浏览 34提问于2019-08-28得票数 1
回答已采纳
2回答
基于我得到的解决方案：
我还尝试使用异步添加计算部分。
安装:Python3.7.4
import msgpack
import threading
import os
import asyncio
import concurrent.futures
import functools
import nest_asyncio
nest_asyncio.apply()
class ThreadSafeElem(bytes):
def __init__(self, * p_arg, ** n_arg):
self._lock = threading.Lock()
def __en
浏览 1提问于2020-07-02得票数 2
回答已采纳
我想知道当我调用asyncio.create_task时会发生什么，而从来没有真正调用等待这个创建的任务。
我有一个简单的程序：
import asyncio
async def simple_task() -> None:
while True:
print("before sleeping")
await asyncio.sleep(2)
print("after sleeping")
async def test():
task = asyncio.create_task(simpl
浏览 3提问于2021-09-13得票数 1
1回答
我正在开发一个控制器应用程序，它监视和控制独立的python可执行的子进程。基本上，我想要的是在controller.py中运行一个asyncio.star_server。在服务器启动和运行之后，controller.py应该作为客户端执行其他python文件，从而连接到它。控制器服务器将永远运行，并创建新的客户端实例，并在必要时向它们发送关机消息。
不幸的是，这是行不通的。没有收到错误，它只是挂起。
controller.py:
async def handleClient(reader, writer):
#handling a connection
addr = writ
浏览 5提问于2020-08-01得票数 0
回答已采纳
我试图找到一种方法来限制使用Python的异步和httpx模块向服务器发出的并发HTTP请求的数量。我偶然发现了这个. StackOverflow
它建议使用asyncio.Semaphore来阻止多个消费者提出太多的请求。虽然这个答案工作得很好，但它使用的是显式循环构造，而不是asyncio.run。当我用asyncio.run替换显式循环构造时，代码的行为会发生变化。现在，它不再执行所有9个请求，而是执行三个请求，然后停止。
import asyncio
from random import randint
async def download(code):
wait_tim
浏览 7提问于2021-04-18得票数 2
回答已采纳
1回答
我通过使用websocket从获取数据。我正在使用。
目前，当票证数据可用时，我将使用以下代码打印它。这是很好的工作，但不是长时间。每隔12-36小时，它就停止产生输出(我认为当Poloniex重新启动服务器时)。
是否有一种优雅的方法来检查ApplicationRunner是否仍然连接，并在断开连接时重新启动它？onDisconnect没有触发。当我运行脚本时，进程不会在套接字停止接收数据时终止，因此我认为事件循环不会停止。
from autobahn.asyncio.wamp import ApplicationSession
from autobahn.asyncio.wamp impo
浏览 2提问于2016-08-21得票数 1
1回答
我正在用aiohttp创建一个web服务器，下面是我用来启动它的代码：
loop = asyncio.get_event_loop()
loop.create_task(main())
loop.run_forever()
我使用run_forever来保持服务器启动，而不是在创建服务器之后关闭它。不幸的是，我现在收到了这样的警告：
/Users/thomas/workspace/eykar/eykache2/eykache/__main__.py:17: DeprecationWarning: There is no current event loop
loop = asyncio.g
浏览 4提问于2022-03-20得票数 0
回答已采纳
1回答
我正在尝试创建两个线程，每个线程都有自己的异步事件循环。
我尝试了下面的代码，但它似乎不起作用：
import asyncio
from threading import Thread
def hello(thread_name):
print('hello from thread {}!'.format(thread_name))
event_loop_a = asyncio.new_event_loop()
event_loop_b = asyncio.new_event_loop()
def callback_a():
asyncio.set_eve
浏览 3提问于2018-09-12得票数 19
回答已采纳
我对在python中使用Asyncio模块很陌生。假设有两个函数我想异步运行。function_A()基本上是在运行循环，这需要在特定条件下用"if“语句停止。
我不确定事件循环到底是如何工作的，只是知道当我运行loop.stop()时，它会杀死内核并重新启动它，这样，在中断事件循环之后要保留的"lst"将在内核被杀死后自动删除。
以下是我想做的事：
global lst
lst = []
import asyncio
async def function_A():
for i in range(0,100):
浏览 3提问于2019-12-04得票数 0
我试图在Windows上测试一些异步功能。我正在使用Python3.7。
这令人痛心地抱怨一些NotImplementedError
import asyncio
import os
import time
import sys
#this works
async def say_after(delay, what):
await asyncio.sleep(delay)
print(what)
#this doesn't
async def test_async(num):
print('Task #{0} start'.format(nu
浏览 1提问于2018-11-03得票数 1
回答已采纳
1回答
考虑这个程序，其中用于停止它的主循环和协程实际上是由我正在使用的一个库实现的。
import asyncio
import signal
running = True
async def stop():
global running
print("setting false")
running = False
await asyncio.sleep(3)
print("reached end")
async def mainloop():
while running:
print("l
浏览 43提问于2018-01-28得票数 1
回答已采纳
此代码失败：
import asyncio
from motor import motor_asyncio
_client = motor_asyncio.AsyncIOMotorClient()
_db = _client.db
users = _db.users
async def main():
await users.create_index(
'login',
unique=True
)
if __name__ == '__main__':
#loop = asyncio.get_e
浏览 1提问于2019-03-29得票数 1
回答已采纳
下面的代码意味着什么吗？如果是的话，使用它的场景是什么？如果睡眠时间不同，有什么不同？
...
while True:
asyncio.get_event_loop().run_until_complete(asyncio.sleep(1))
...
浏览 4提问于2021-06-01得票数 0
回答已采纳
3回答
我正在使用Python3相对较新的模块来正确理解和实现两个并发运行的对象。
简而言之，异步似乎旨在通过事件循环处理异步进程和并发Task执行。它提倡使用await (在异步函数中应用)作为一种无回调的方式来等待和使用结果，而不阻塞事件循环。(期货和回调仍是可行的选择。)
它还提供了asyncio.Task()类，这是Future的一个专门子类，用于包装协同。最好使用asyncio.ensure_future()方法调用。异步任务的目的是允许独立运行的任务与同一事件循环中的其他任务“并发”运行。我的理解是，Tasks连接到事件循环，然后事件循环会自动地驱动await语句之间的协同。
我喜欢在不需
浏览 5提问于2015-03-26得票数 88
回答已采纳
我做了一个虚拟服务器来测试我的websockets应用程序。它侦听subscription消息，然后通过套接字提供有关这些订阅的信息。
类的subscriptions属性在初始化时为空，在listen()函数接收订阅消息时应该会填满。但是，talk()中的self.subscriptions似乎从未被追加，使其陷入无限的while循环中，并且从不传输消息。
这个问题可以通过在for循环后添加一行await asyncio.sleep(1)来解决。但是为什么呢？是否应该在每次启动for循环时重新计算self.subscriptions？
代码如下：
class DummyServer:
浏览 76提问于2018-06-08得票数 3
回答已采纳
1回答
我试图将事件侦听器附加到python子进程，每当进程关闭/退出时调用该子进程。回调将重新启动子进程，并将相同的事件侦听器附加到新进程。
类似于从.on调用child_process in node.js的东西
我已经知道了。但理想情况下，我希望使用来完成这个任务，而不是在单独的线程中运行每个事件侦听器。
我在想这样的事-
from asyncio import subprocess as asubprocess
from typing import Callable, Awaitable
async def handle_close(proc: asubprocess.Process, sp
浏览 0提问于2020-11-26得票数 1
回答已采纳
据我所知，asyncio.test_utils并不是故意记录的，因为它是用于私人用途的(请参阅此)。
然而，我想知道asyncio.test_utils.run_briefly的剂量。
例如，在这里，你能解释一下吗？
def test_gather_shield(self):
child1 = asyncio.Future(loop=self.loop)
child2 = asyncio.Future(loop=self.loop)
inner1 = asyncio.shield(child1, loop=self.loop)
i
浏览 0提问于2018-05-23得票数 1
回答已采纳
我有以下代码
import asyncio
loop = asyncio.get_event_loop()
async def while_loop():
n = 0
while True:
print(f"{n}")
await asyncio.sleep(2)
n = n+1
async def some_func():
await asyncio.sleep(5)
print("Some Func")
future = loop.create_task(while_lo
浏览 0提问于2018-05-30得票数 23
回答已采纳
我正在努力理解asyncio.create_task实际上是如何工作的。假设我有以下代码：
import asyncio
import time
async def delayer():
await asyncio.sleep(1)
async def messenger():
await asyncio.sleep(1)
return "A Message"
async def main():
message = await messenger()
await delayer()
start_time = time.time()
浏览 2提问于2022-11-17得票数 0
2回答
使用这个异步代码，我的导师说，所有的协同(这里是50 "fetch_page")首先在第一个async with停止并等待，然后所有的它们都从那里继续，在第二个async with停止，最后它们都返回。
import aiohttp
import asyncio
async def fetch_page(url):
print(1)
async with aiohttp.ClientSession() as session:
print(2)
async with session.get(url) as response:
浏览 0提问于2019-03-14得票数 1
回答已采纳
1回答
使用我可以编写的纯TCP异步服务器的最简单示例，我希望获得当前线程的线程id。因为我在一个async协同器中，所以我认为这将是一个不同的线程(特别是使用asyncio库)。但是结果总是打印相同的id值。我遗漏了什么？是错误的函数调用吗？asyncio没有创建一个新线程吗？
import asyncio
import threading
from asyncio import StreamWriter, StreamReader
HOST = '127.0.0.1'
PORT = 7070
async def handle(reader: StreamReader, writ
浏览 0提问于2020-11-22得票数 0
回答已采纳
我编写的代码似乎可以做我想做的事情，但我不确定这是否是一个好主意，因为它混合了线程和事件循环，在主线程上运行一个无限循环。这是一个很小的代码片段，它捕获了我正在做的事情的想法：
import asyncio
import threading
msg = ""
async def infinite_loop():
global msg
while True:
msg += "x"
await asyncio.sleep(0.3)
def worker():
loop = asyncio.new_even
浏览 3提问于2018-03-31得票数 4
回答已采纳
1回答
简单地说，thread-safe意味着当多个thread访问同一资源时是安全的，而且我知道Asyncio从根本上使用单个thread。
但是，多个Asyncio Task可以一次访问多个资源，比如multi-threading。
例如，DB连接(如果对象不是thread-safe并支持Asyncio操作)。
调度访问同一个DB对象的Task A和Task B。
IO循环执行Task A。
DB对象上的Task A await IO操作。(这将花费足够长的时间)
IO循环执行Task B
Step3的IO操作仍在进行中(尚未完成)。
对同一个DB对象执行Task B aw
浏览 0提问于2018-02-24得票数 8
回答已采纳
这是asyncio教程中的基本tcp服务器：
import asyncio
class EchoServerClientProtocol(asyncio.Protocol):
def connection_made(self, transport):
peername = transport.get_extra_info('peername')
print('Connection from {}'.format(peername))
self.transport = transport
def
浏览 1提问于2015-07-31得票数 2
1回答
我正在学习python asyncio，并使用它们测试许多代码。
下面是我尝试使用asyncio和aiohttp订阅多个Websocket流的代码。
我不明白为什么当coro(item1, item2): async with ... 作为一个任务执行时，它不会进入async with ...块。(即"A“是打印出来的，而不是"B").
有人能帮我理解原因吗？
(我已经有了一个，但我只是想了解这背后的机制。)
代码
import aiohttp
import asyncio
import json
async def coro(
item
浏览 0提问于2021-06-19得票数 3
回答已采纳
在看了一段关于使用websocket服务器与视频游戏(我的世界)中的实体进行交互的youtuber的视频后：
我想要重新创造同样的想法，但通过一些小小的调整：
I希望websocket服务器成为python中的主机，我希望能够在没有html或javascript的情况下进行交互。
因此，我构建了websocket服务器：
#!/usr/bin/env python
import asyncio
import websockets
async def server(websocket, path):
data = await websocket.recv()
whi
浏览 2提问于2021-02-09得票数 0
2回答
精神病学/异步集偶数循环策略
、、、、
希望你没事！
模块存在问题，允许与PostgreSQL数据库进行交互。
当我正常启动HTTP服务器(我使用和)并向服务器发送请求时，我有以下错误：
error connecting in 'pool-1': Psycopg cannot use the 'ProactorEventLoop' to run in async mode. Please use a compatible event loop, for instance by setting 'asyncio.set_event_loop_policy(WindowsSelectorEvent
浏览 31提问于2022-06-19得票数 0
1回答
目前，我的所有函数都是用@tornado.gen.coroutine装饰的，然后我就放弃了。我想搬到新的async/await。
要移动到异步，是否意味着我需要使用异步IOLoop启动旋风，如文档所示：
from tornado.platform.asyncio import AsyncIOMainLoop
import asyncio
AsyncIOMainLoop().install()
asyncio.get_event_loop().run_forever()
我改变了一些共同例程来使用async/await而不是yield，这似乎适用于旧的旋风式IOLoop，为什么如果我没有显式地使
浏览 3提问于2016-11-07得票数 1
回答已采纳
这与类似，但我认为有必要提出一个新的问题。
我有一个简单的服务器设置如下
loop.create_unix_server(lambda: protocol, path=serverSocket)
很好，如果我这么做的话
def data_received(self, data):
data = b'data reply'
self.send(data)
我的当事人得到了答复。但我无法让它处理任何类型的asyncio调用。我试过以下所有的方法，但没有一种有效。
@asyncio.coroutine
def go(self):
yield from asy
浏览 3提问于2015-03-18得票数 11
回答已采纳
1回答
async def func1():
print(f'{datetime.now().time()} func1 start')
await asyncio.sleep(1)
print(f'{datetime.now().time()} func1 over')
async def func21():
print(f'{datetime.now().time()} func21 start')
await asyncio.sleep(1)
print(f'{datetime.now()
浏览 3提问于2022-08-17得票数 0
2回答
有没有一种方法可以在不等待异步函数完成的情况下从同步函数调用它？
我目前的测试：
问题:等待test_timer_function完成
async def test_timer_function():
await asyncio.sleep(10)
return
def main():
print("Starting timer at {}".format(datetime.now()))
asyncio.run(test_timer_function())
print("Ending timer at {}"
浏览 7提问于2022-10-20得票数 3
嗯，我刚开始在python中异步操作。我正在使用调用asyncio.start_server创建一个服务器，问题是我运行了两次相同的循环，第一次创建/启动服务器调用loop.run_until_complete，然后运行loop.run_forever。这是我使用的密码。
if __name__ == '__main__':
loop = asyncio.get_event_loop()
sv_wrapper = ServerWrapper(
host='localhost',
port=5003
)
浏览 3提问于2017-10-30得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
