Python 使用带有嵌套循环的asyncio nested_future（）和gather（）

在尝试并行执行一些异步函数时，我总是会遇到一个错误，我希望能够理解

在Python3.5.1上运行asyncio，我将通过ClientSession和aiopg（异步psycopg2）调用组合aiohttp

其主要思想是，我有一个循环，从一个表中读取行，对行进行循环，并并行执行对函数row_loop的几个调用，该函数将异步启动一个web请求GET，然后通过另一个游标将每一行的结果写入同一个DB

sure_future（）和gather（）似乎工作正常，但只有第一次DB写入成功，另一次导致异常，抱怨另一个协程已经在等待

Traceback (most recent call last):
  File "sandbox/loop.py", line 148, in write_dict
    await cur2.execute(INSERT, (tuple(adict.values()),))
  File "/Users/mrigal/.virtualenvs/py35/lib/python3.5/site-packages/aiopg/cursor.py", line 103, in execute
    waiter = self._conn._create_waiter('cursor.execute')
  File "/Users/mrigal/.virtualenvs/py35/lib/python3.5/site-packages/aiopg/connection.py", line 211, in _create_waiter
    'data' % func_name)
RuntimeError: cursor.execute() called while another coroutine is already waiting for incoming data

问题可能在aiopg库中，也可能是我正在针对main注册循环，而不是针对实际发生.gather（）的函数。但是我找不到关于它的文档

如果不使用sure_future（）和gather（），代码会很慢，因为每个调用都是一个接一个地完成的。我可能不太了解gather（）的用途，可能需要一个真正的多线程解决方案，但我想先测试这个中间步骤

这是我的实际代码：

async def make_get(row, session, spec_country_code=None):
    result = await session.get(URL, country=spec_country_code)
    if not spec_country_code and result.country != row.get('country'):
        return await make_get(row, session, spec_country_code=result.country)
    return result


async def write_dict(conn, adict):
    async with conn.cursor() as cur2:
        await cur2.execute(INSERT_QUERY, (tuple(adict.values()),))


async def row_loop(conn, row, session):
    result = await make_get(row=row, session=session)
    if result.status == 'OVER_QUERY_LIMIT':
        raise OverQueryLimitException()
    else:
        adict = build_adict(row, result)
    await write_dict(conn=conn, adict= adict)
    return result.status


async def write_loop(conn):
    failed_count = 0
    rows = []
    async with aiohttp.ClientSession() as session:
        async with conn.cursor(cursor_factory=DictCursor) as cur
            await cur.execute((SELECT_QUERY))
            async for row in cur:
                # THIS WORKS, BUT I WOULD LIKE TO USE gather()
                # try:
                #     status = await row_loop(conn=conn, row=row, session=session)
                # except OverQueryLimitException:
                #     break
                # if status != 'OK':
                #     failed_count += 1
                rows.append(asyncio.ensure_future(
                    row_loop(conn=conn, row=row, session=session)))
        responses = await asyncio.gather(*rows)
        print(len(responses._children))  # Just a try
    return cur.rownumber, failed_count


def print_result(mode, select_count, failed_count):
    print("Tried to {} {} new entries".format(mode, select_count))
    print("Found {} failed/skipped entries".format(failed_count))


async def insert_new(conn):
    select_count, failed_count = await write_loop(conn=conn)
    print_result('insert', select_count, failed_count)


async def main():
    async with aiopg.create_pool('db_string') as pool:
        async with pool.acquire() as conn:
            await insert_new(conn=conn)


loop = asyncio.get_event_loop()
loop.run_until_complete(main())

（更新：添加了关于同一连接中并发游标执行的信息和示例）

aiopg不允许在同一连接上同时使用两个游标：必须在执行新命令之前关闭游标：

import asyncio

import aiopg

DSN = 'dbname=aiopg'  # to create, run: `createdb aiopg`


async def test_cursor(conn):
    async with conn.cursor() as cur:
        await cur.execute("SELECT 1")
        async for row in cur:
            print(row)


async def go():
    async with aiopg.create_pool(DSN) as pool:
        async with pool.acquire() as conn:
            print("part 1:")
            await test_cursor(conn)
            await test_cursor(conn)

            print("part 2:")
            await asyncio.wait([test_cursor(conn), test_cursor(conn)])  # fails


loop = asyncio.get_event_loop()
loop.run_until_complete(go())
loop.close()

您可以尝试通过使用多个连接绕过此问题，但是：

虽然这不能直接回答具体问题，但我想建议一个通用解决方案：数据库访问（在本地/LAN主机中，用于读写）通常被认为非常快，尤其是与远程（WAN）HTTP请求相比。在这个程序中使用同步数据库访问可能不会使它变慢，但会降低它的复杂性。在不使用aiopg的情况下，尝试以下方式：

async def main():
    rows = get_rows_from_db()  # sync
    async with aiohttp.ClientSession() as session:
        tasks = [process_row(session, row) for row in rows]
        responses = await asyncio.gather(*tasks)


async def process_row(session, row):
    async with session.get(url) as response:
        result = await response.text()
    write_db_result(row, result)  # sync db access


loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()

---

谢谢你宝贵的回答。我在文档中找不到任何关于“aiopg不允许在同一连接上同时使用两个游标”的提及，也许应该添加它。。。我第一次开始同步使用DBs，但也想尝试异步使用！）它就像一个魅力传递池，用于后面的方法，使用一个连接进行阅读，另一个连接进行写作：）我还添加了一个信号量以避免无限的并行工作：）酷！请记住，使用多个连接。我很高兴听到通过asyncio使用DB是否会在实际场景中带来性能提升（我猜不会！）：-）正如我所说，它以前已经工作过了，事实上，DB部分只占执行时间的2-5%。因此，任何可能的改进都比并行进行的web调用的自然变化要慢。我最感兴趣的是拥有一个“完全异步”的代码，因为我知道从一个表中读取并写入另一个表不会导致锁定或查看旧数据：）@Udi感谢创建和添加aiopg标记：）