具有多个服务器的Asyncio循环
是指使用Asyncio库进行异步编程时，可以创建多个服务器并将它们组织在一个循环中。Asyncio是Python的一个异步IO框架，它允许开发者使用协程（coroutines）来实现异步操作。
在具有多个服务器的Asyncio循环中，每个服务器可以处理多个并发的客户端请求。这种设计模式可以提高服务器的并发性能和吞吐量。通过Asyncio的事件循环机制，可以轮流处理多个任务，并在任务完成时进行切换，而无需等待某个任务完成才能继续执行其他任务。
优势：
- 高并发性能：Asyncio的异步特性使得多个客户端请求可以并行处理，提高了服务器的并发性能。
- 高效利用资源：使用异步IO可以在等待IO操作完成时执行其他任务，充分利用CPU资源。
- 简化代码：Asyncio的协程编程模式可以简化异步编程的复杂性，使代码更易于理解和维护。
应用场景：
- Web服务器：通过使用多个服务器的Asyncio循环，可以实现高性能的Web服务器，能够处理大量并发请求。
- 实时应用程序：对于需要实时数据交互的应用程序，使用Asyncio的异步特性可以提供快速响应和实时更新。
- 大规模分布式系统：在分布式系统中，通过使用多个服务器的Asyncio循环，可以实现高性能和可扩展性。
腾讯云相关产品：
- 弹性云服务器（ECS）：腾讯云的弹性云服务器提供了高性能、安全可靠的虚拟服务器实例，适用于各类应用场景。
- 云函数（SCF）：腾讯云的云函数是一种事件驱动的无服务器计算服务，能够实现按需运行代码逻辑，无需管理服务器。
参考链接：
- 腾讯云弹性云服务器（ECS）：https://cloud.tencent.com/product/cvm
- 腾讯云云函数（SCF）：https://cloud.tencent.com/product/scf
相关·内容
我正在尝试使用Python Websockets库构建一个服务器和客户端。我遵循这里给出的例子：Python OCPP documentation。我想编辑这个例子，这样对于每个新的客户端(Charge Point)，服务器(中央系统)在新的线程(或新的循环，因为Websockets库使用Python的异步)上运行。基本上，我希望同时从多个客户端接收消息。我修改了服务器(中央系统)的main方法，从我遵循的例子开始，像这样在websockets.serve()中添加了一个循环参数，希望每当有新的客户端运行时，它都会运行在不同的循环上： async def main():
server
浏览 189提问于2020-04-26得票数 0
回答已采纳
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
回答已采纳
我很难理解asyncio的整个概念。现在，我尝试将Socket模块和asyncio一起使用，使UDP聊天同时作为服务器和客户端工作。在两个asyncio协程中，我运行循环(一个用于服务器，一个用于客户端)。但是程序只能作为客户端工作。在网络上发送数据，但不接收数据。我猜对于这种情况有更好的asyncio解决方案，但在继续之前，我想了解为什么特定的代码不工作。你有什么线索吗？
# PYTHON 3.4
import asyncio
import socket
PORT = 50001
MAX_BYTES = 8400
LOCAL_IP = ''
REMOTE_IP = '
浏览 2提问于2016-02-21得票数 1
在Python3.8.0中尝试使用一些异步代码时，我偶然发现了以下情况。我有client.py，它可以用server.py中的服务器异步处理连接。这台服务器假装做了一些工作，但实际上睡了几秒钟，然后返回。我的问题是，既然服务器运行在一个完全不同的进程中，那么为什么睡眠方法是否阻塞很重要?如果服务器端的进程可能没有阻塞，那么首先执行这样的异步调用有什么好处呢？
# client.py
import time
import asyncio
import aiohttp
async def request_coro(url, session):
async with session.
浏览 2提问于2020-01-08得票数 1
回答已采纳
1回答
一个我还没能找到答案的非常简单的问题：
如果我想在自己的线程中运行异步事件循环，并让它将消息发送回主线程，它是否可以使用queue.Queue实例来执行此操作？
如果这确实是可能的和安全的，有没有更好的方法将消息从非主线程中的异步循环传递到主线程？
这里有一个玩具示例，它似乎是有效的：
import asyncio
from queue import Queue
import threading
queue_to_main = Queue()
async def coro1():
for i in range(5):
queue_to_main.put_nowa
浏览 2提问于2017-11-01得票数 1
我在Ubuntu上使用PythonWebSockets4.0.1。我想有两个websocket服务器运行。我能够通过为每个线程创建2个线程和独立的事件循环来实现“某种工作”。所谓“工作”，我指的是两种websockets的工作和响应大约30秒，然后其中一个停止。我必须重新启动这个过程才能让他们两个人重新开始工作。如果我只运行这两个线程中的一个或另一个，那么单个websocket将永远工作。
我做错了什么，如何让两个websockets永远使用异步操作？
# Start VL WebSocket Task
class vlWebSocketTask (threading.Thread):
浏览 1提问于2018-02-16得票数 5
回答已采纳
1回答
我一直试图并行运行两个asyncio循环，但我找不到关于如何做到这一点的有意义的指令。我想同时执行两个异步函数，而这两个函数都依赖于一个全局变量。 我的代码如下所示： import asyncio
#a---------------------------------------------------------------
async def foo(n):
print("Executing foo(n)")
return n**2
async def main_a():
print("Executing main_a()")
浏览 51提问于2021-08-20得票数 1
回答已采纳
下面是我的基本代码
def heavylifting(self):
# Do the heavy lifting
print('Done!')
async def async_heavylifting(self):
await self.heavylifting()
以下是不起作用的各种方法：
Example1 -什么都没发生
def do_the_things(self):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
asyncio.run_coroutine_thread
浏览 3提问于2020-03-11得票数 0
我们都知道，使用异步大大提高了套接字服务器的性能，显然，如果我们能够利用cpu中的所有内核(可能通过多处理模块或os.fork()等)，事情会变得更棒。
现在，我正在尝试构建一个多核套接字服务器演示，一个异步套接字服务器监听每个核心，并且所有绑定到一个端口。只需创建一个异步服务器，然后使用os.fork()，就可以让进程具有竞争力。
然而，当我试图分叉时，单核精细代码会遇到一些麻烦。似乎在epoll选择器模块中注册来自不同进程的相同文件压缩程序存在一些问题。
我给你看了下面的代码，有人能帮我吗？
下面是一个简单的、逻辑上清晰的回显服务器代码，它使用异步：
import os
import a
浏览 1提问于2019-06-01得票数 2
回答已采纳
这是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回答
我想用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
回答已采纳
我不能让我的使用者和我的生产者同时运行，这似乎是worker()，或者aiohttp服务器被阻塞了--即使同时使用asyncio.gather()执行。
如果我做了loop.create_task(工作者)，这将阻止和服务器永远不会启动。
我尝试了我能想象到的每一个变体，包括nest_asyncio模块--而且我只能让这两个组件中的一个运行。
我做错了什么？
async def worker():
batch_size = 30
print("running worker")
while True:
if queue.qsize() &
浏览 9提问于2020-08-09得票数 1
回答已采纳
我对异步非常陌生，我发现EchoServer示例非常令人费解。我试图实现一种简单的情况:服务器接受多个客户端，在协同线中运行该客户端并处理数据，以及一个处理ncurses输入的UI线程。我现在有以下内容，在代码中，它传达了我认为的想法。但不起作用。
import asyncio
async def do_ui():
await asyncio.sleep(1)
print('doing')
await do_ui()
async def run_game():
loop = asyncio.get_running_loop()
se
浏览 5提问于2021-12-23得票数 1
回答已采纳
1回答
我从websockets和asyncio开始，很难理解背后的逻辑。过去，我使用Python上的线程，以及Javascript上的AJAX调用(因此我了解多线程(I/O绑定)的概念，以及对结果异步操作的过程的调用)。
示例服务器如下所示。我的目标是提供一个websocket连接和两个函数，它们将每10秒调用一次，而无需等待结果(因此，不管处理函数需要多长时间，每10秒就调用一个函数)。
import time
import arrow
import websockets
import asyncio
async def time1(websocket):
# simulation of
浏览 3提问于2016-12-12得票数 3
回答已采纳
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
2回答
我真的很难理解异步事件循环和多个工作者/线程/进程之间的交互。
我用的是破折号:里面用的是烧瓶和火绒。
假设我有两个功能
def async_download_multiple_files(files):
# This function uses async just so that it can concurrently send
# Multiple requests to different webservers and returns data.
def sync_callback_dash(files):
# This is a sync function t
浏览 7提问于2021-05-18得票数 1
1回答
我很难理解修改后的回送服务器的行为，它试图利用python3的asyncio模块。
本质上，我有一个无限循环(假设我想无限期地将一些数据从服务器流到客户端，而连接已经建立)，例如MyServer.py
#! /usr/bin/python3
import asyncio
import os
import time
class MyProtocol(asyncio.Protocol):
def connection_made(self, transport):
peername = transport.get_extra_info('peername'
浏览 0提问于2018-06-22得票数 6
回答已采纳
1回答
下面的代码用于在HTTP循环中异步发送多个HTTP请求，并根据来自每个请求的响应(请求"X“总是返回"XXX"，"Y”总是返回"YYY“等等)，做一些事情并为每个请求指定的interval秒睡眠。
然而，它会抛出一个错误..。
RuntimeError: cannot reuse already awaited coroutine
有人能帮助我如何修正代码来实现预期的行为吗？
class Client:
def __init__(self):
pass
async def run_forever(self, coro,
浏览 4提问于2021-09-12得票数 0
回答已采纳
2回答
何时使用多个事件循环？
、、、、
我有一个网络应用程序建立在一个Python 3.5+异步框架(apistar，sanic等)。该应用程序进行各种IO调用-对数据库、Redis等-也是异步的。
建议使用额外的事件循环：
import asyncio
import peewee
from peewee_async import Manager, PostgresqlDatabase
loop = asyncio.new_event_loop() # Note: custom loop!
database = PostgresqlDatabase('test')
objects = Manager(databas
浏览 2提问于2017-11-21得票数 15
全!
我需要向web服务发出大约10,000个请求，并且我期望JSON响应。由于请求是相互独立的，所以我希望并行运行它们。我认为aiohttp可以帮我这个忙。我编写了以下代码：
import asyncio
import aiohttp
async def execute_module(session: aiohttp.ClientSession, module_id: str,
post_body: dict) -> dict:
headers = {
'Content-Type': r
浏览 8提问于2019-11-22得票数 8
2回答
因此，我正在使用await asyncio.create_subprocess_shell(args,stdout=asyncio.subprocess.PIPE,limit=self.chunk_size)阅读许多进程的标准输出，并从“等待”的结果中获得标准输出。返回的是异步的StreamReader，在其中，我使用read(self.chunk_size)协同器将队列中的每个块放在首位，该队列由一些线程处理。
它能够很好地运行，但是我正在处理大量的stdout，并且我看到内存使用量增长缓慢。
我感到困惑的是，为什么当我限制要写入stdout的缓冲区大小时，内存的使用会继续增加。我认为设置限
浏览 10提问于2021-02-01得票数 0
回答已采纳
我在设置的异步服务器上遇到了问题。我对这个话题做了很多研究，但似乎找不到任何有用的东西。本质上，我的服务器正在监听端口，但是当我从“客户端”发送消息时，它似乎发送了大量的消息。以前我一直在使用多线程的套接字服务器，但经过一些研究之后，异步服务器似乎更适用于我的项目。
我不确定设置服务器的最佳方式，所以任何关于最佳实践的建设性反馈以及什么不是都会受到极大的赞赏。
lia_server.py
import logging
import asyncio
from datetime import datetime
from os import path
logging.basicConfig(leve
浏览 2提问于2021-07-14得票数 0
回答已采纳
我正在尝试理解如何使用异步流进行多个连接，这些连接将一直发送消息，直到预定义的条件或套接字超时为止。查看Python文档，它们为基于异步流的TCP服务器提供了以下示例：
import asyncio
async def handle_echo(reader, writer):
data = await reader.read(100)
message = data.decode()
addr = writer.get_extra_info('peername')
print(f"Received {message!r} from {a
浏览 11提问于2022-08-22得票数 0
回答已采纳
我想从客户端-服务器发送来自for循环的值，但服务器只接收第一个值，连接很快就会被切断
客户端
import asyncio
import websockets
import time
async def message():
async with websockets.connect("ws://-------:5051") as socket:
for i in range(20):
await socket.send(f"{i}")
print(i)
tim
浏览 0提问于2020-06-27得票数 0
1回答
我想用main.py的超级玉米启动我的main.py应用程序。
我使用这个命令手动启动服务器：
hypercorn --access-logformat "%(R)s %(s)s %(st)s %(D)s %({Header}o)s" --access-logfile - -b 0.0.0.0:8000 -w 9 app:app
现在我需要从我的代码中做同样的事情。第一次尝试是：
from hypercorn.config import Config
from hypercorn.asyncio import serve
from api.app import app # a
浏览 12提问于2021-10-27得票数 2
我已经写了一个异步函数，它收集多个文本数据，并进行批量数据处理。在此之后，它返回输出，如下所示：
import sys
import asyncio
Model_runner():
'''
The model runner combines all the input coming to it and combines in a batch of 10 or 1 sec, which ever duration is less.
After combining, it does processing and returns the outpu
浏览 0提问于2020-10-13得票数 0
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回答
关闭/关闭
、、
我扩展了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
回答已采纳
我正在尝试使用asyncio实现一个简单的回声服务器。这是我的尝试：
import asyncio
async def process(reader, writer):
while True:
data = await reader.readline()
writer.write(data)
loop = asyncio.get_event_loop()
listener = asyncio.start_server(process, host=None, port=2500)
loop.run_until_complete(listener)
lo
浏览 11提问于2017-12-30得票数 2
回答已采纳
我正在使用aiohttp编写REST API。 一些协程需要使用aiomysql library调用数据库。aiomysql的文档包含以下示例： import asyncio
import aiomysql
loop = asyncio.get_event_loop()
async def test_example():
conn = await aiomysql.connect(host='127.0.0.1', port=3306,
user='root', pas
浏览 32提问于2020-11-11得票数 2
回答已采纳
1回答
使用异步的多个循环
、、、、
asyncio可以有多个循环吗？如果回答是yes，我该怎么做呢？我的用例是：*我从异步的网站列表中提取url *对于每个“子url列表”，我将在异步/中抓取它们。
提取urls的示例：
import asyncio
import aiohttp
from suburls import extractsuburls
@asyncio.coroutine
def extracturls(url):
subtasks = []
response = yield from aiohttp.request('GET', url)
suburl_list = yi
浏览 1提问于2014-12-10得票数 21
回答已采纳
1回答
我在我的应用程序中使用异步，对于将事件循环作为参数传递有点困惑。
使用事件循环编写函数/方法有三种可能性
将异步事件循环作为参数传递
不要为事件循环使用参数，而使用asyncio.get_event_loop()
可选地将事件循环作为参数传递。如果没有传递，请使用asyncio.get_event_loop()
最后一种情况似乎大部分时间都在使用，但即使在异步api中，使用也是不一致的。由于我不缩进使用两个独立的事件循环，那么在需要的地方使用asyncio.get_event_loop()是什么意思呢？
最好的办法是什么？
浏览 5提问于2016-10-31得票数 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
1回答
首先，我想尽可能快地使用一个连接发送多个请求。下面的代码运行得又快又好，但我想让它超越异步。回到我的问题，是否有可能使用多线程或多处理并行运行它。我听说你可以用ThreadPoolExecutor或ProcessPoolExecutor。
import random
import asyncio
from aiohttp import ClientSession
import time
from concurrent.futures import ProcessPoolExecutor
async def fetch(sem,url, session):
async with sem
浏览 3提问于2016-11-03得票数 5
我正在尝试测试我是否同时发送多个请求，使用coroutine可以导致服务器端接收损坏的数据。
我的测试基于来自：的示例代码
不知为何，对于下面的代码，服务器端只接收一个请求？有人有洞察力吗？thx
服务器(这基本上是websockets入门网页上的相同代码)：
#!/usr/bin/env python3
浏览 0提问于2021-08-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. IO绑定(网页获取) -> 2. cpu绑定(处理信息) -> 3. IO绑定(将结果写入数据库)。
我目前正在使用aiohttp来获取网页。我目前正在使用asyncio.as_completed收集步骤1的任务，并在完成后将它们传递给步骤2。我担心的是，这可能会消耗cpu资源并阻塞步骤2中的程序流，从而干扰步骤1任务的完成。
我曾尝试使用ProcessPoolExecutor将Step 2任务外包给其他进程，但Step 2任务使用不可拾取的数据结构和函数。我尝试过ThreadPoolExecutor，虽然它起作用了(例如，它没有崩溃)，但我的理
浏览 0提问于2021-05-26得票数 0
我正在使用Python3 Asyncio模块创建一个负载平衡应用程序。我有两个繁重的IO任务：
SNMP轮询模块，它确定最佳的服务器。
一个“类似代理”的模块，它平衡对所选服务器的请求。
这两个进程都将永远运行，彼此独立，不应被另一个进程阻塞。
我不能使用一个事件循环，因为它们会彼此阻塞，有没有办法有两个事件循环，或者我必须使用多线程/处理？
我试过使用asyncio.new_event_loop()，但没有设法使它工作。
浏览 11提问于2015-07-25得票数 46
我正在尝试测试我的python 3.4.3http客户机或应用程序，它们将http请求发送到服务器。如果服务器因为某种原因而延迟响应，我希望请求不会被阻塞，因为asyncio+aiohttp应该提供异步调用：
def post(self):
print("received post")
print(self.request)
print("POST Body: %s" % str(self.request.body))
time.sleep(3)
self.write("blah")
self.fi
浏览 0提问于2018-01-30得票数 0
1回答
我以前在Python中玩过线程处理，但决定尝试一下asyncio模块，特别是因为您可以取消运行中的任务，这似乎是一个很好的细节。然而，出于某种原因，我不能把我的头围绕在它上面。
下面是我想要实现的东西(如果我使用的术语不正确，很抱歉)：
一个downloader线程，它每x秒下载一次相同的文件，检查它的散列是否与上一次下载相同，如果它不一样的话保存它。
在后台运行的webserver线程，允许对downloader线程进行控制(暂停、列表、停止)。
我使用aiohttp作为the服务器。
到目前为止，这就是我所拥有的：
class aiotest():
def __i
浏览 2提问于2016-03-19得票数 4
回答已采纳
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
回答已采纳
我在pyqt上使用了quamash loop (异步)和其他模块来通过异步连接到RethinkDB。如果我不使用quamash，RethinkDb模块会以完美的方式连接。但当使用quamash循环时，尽管将其放在每个关键参数循环上，它都会失败，如下所示：
File "/home/dpineda/.virtualenvs/dragoncharts/lib/python3.6/site-packages/rethinkdb/asyncio_net/net_asyncio.py", line 148, in connect
loop=self._io_loop)
Fi
浏览 0提问于2018-01-19得票数 1
下面代码中的两个coroutintes运行在不同的线程中，不能通过asyncio.Queue相互通信。在producer在asyncio.Queue中插入一个新项后，consumer无法从该asyncio.Queue中获取该项，它将在方法await self.n_queue.get()中被阻塞。
我尝试在asyncio.Queue的consumer和producer中打印I，发现它们是相同的。
import asyncio
import threading
import time
class Consumer:
def __init__(self):
self.n
浏览 8提问于2022-03-03得票数 1
1回答
考虑这两个Python代码片段： import asyncio
import time
async def say_after(delay, what):
await asyncio.sleep(delay)
print(what)
async def main():
print(f"started at {time.strftime('%X')}")
await say_after(1, 'hello')
await say_after(2, 'world')
print
浏览 15提问于2021-04-06得票数 0
回答已采纳
我想在单独的线程中启动websocket服务器。我已经尝试实现如下，但得到运行时错误，因为它说附加到不同的循环 代码： #!/usr/bin/env python
# WS server example
import asyncio
import websockets
import threading
import time
async def hello(websocket, path):
name = await websocket.recv()
print(name)
greeting = "Hello " + name +"!&
浏览 263提问于2021-05-05得票数 2
我编写的代码似乎可以做我想做的事情，但我不确定这是否是一个好主意，因为它混合了线程和事件循环，在主线程上运行一个无限循环。这是一个很小的代码片段，它捕获了我正在做的事情的想法：
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回答
我正在学习Python中的异步。有一种困惑，我不能把我的头绕过去。
假设我有两个Python脚本:tumy1.py和tumy2.py。在第一个脚本中，我的代码如下所示：
loop = asyncio.get_event_loop()
loop.create_task(a_task)
第一个脚本将导入到第二个脚本中，在第二个脚本中，我将我的代码安排如下：
loop = asyncio.get_event_loop()
loop.run_forever()
是否创建了两个不同的事件循环？谢谢你们的时间伙计们！
浏览 0提问于2021-12-04得票数 1
回答已采纳
我正在构建一个web抓取API，我的大部分抓取都是用AsyncIO协同器完成的，如下所示：
async def parse_event(self):
do scraping
# call the func
asyncio.run(b.parse_event())
这非常好，但由于我是同时刮多个网站，我最初是使用concurrent.futures.ThreadPoolExecutor来使用多个线程的擦拭。但是，由于我已经实现了coroutine逻辑，所以现在不能在线程中直接使用asyncio.run方法。
以前(没有协同剂)：
with concurrent.futures.Threa
浏览 3提问于2021-10-26得票数 4
1回答
我有一个功能是
data=[]
async def connect(id):
d= await database_sync_to_async(model.objects.filter())
data.append(d)
我称之为连接函数
import asyncio
loop = asyncio.get_event_loop()
try:
# run_forever() returns after calling loop.stop()
tasks =[connect(1),connect(2),connect(3),connect(4),connect(5)]
浏览 1提问于2021-02-08得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
