web-dev-qa-db-ja.com

既存のブロッキングライブラリでasyncioを使用する方法

いくつかのブロッキング関数foo、barがあり、それらを変更できません（一部の内部ライブラリは制御できません。1つ以上のネットワークサービスと通信します）。どのように非同期として使用しますか？例えば。次のことはしたくない。

results = []
for inp in inps:
    val = foo(inp)
    result = bar(val)
    results.append(result)

最初のfooを待っている間に2番目の入力に対してbarを呼び出すことができるため、これは非効率的です。それらをasyncioで使用できるようにラップする方法（つまり、新しいasync、await構文）？

関数が再入可能であると仮定しましょう。つまり、以前のfooがすでに処理されているときに、fooを再度呼び出すことは問題ありません。

更新

再利用可能なデコレーターで拡張された答え。たとえば ここ をクリックします。

def run_in_executor(f):
    @functools.wraps(f)
    def inner(*args, **kwargs):
        loop = asyncio.get_running_loop()
        return loop.run_in_executor(None, functools.partial(f, *args, **kwargs))

    return inner
pythonpython-3.xasync-awaitpython-3.5python-asyncio
23
balki

ここには（種類の）2つの質問があります。1つ目は、ブロッキングコードを非同期で実行する方法、2つ目は、非同期コードを並列で実行する方法です（asyncioはシングルスレッドなので、GILは引き続き適用されるため、適用されませんtruly同時ですが、私は余談です）。

文書化された here のように、asyncio.ensure_futureを使用して並列タスクを作成できます。

同期コードを実行するには、 executorでブロッキングコードを実行する が必要です。例：

import concurrent.futures
import asyncio
import time

def blocking(delay):
    time.sleep(delay)
    print('Completed.')

async def non_blocking(loop, executor):
    # Run three of the blocking tasks concurrently. asyncio.wait will
    # automatically wrap these in Tasks. If you want explicit access
    # to the tasks themselves, use asyncio.ensure_future, or add a
    # "done, pending = asyncio.wait..." assignment
    await asyncio.wait(
        fs={
            # Returns after delay=12 seconds
            loop.run_in_executor(executor, blocking, 12),

            # Returns after delay=14 seconds
            loop.run_in_executor(executor, blocking, 14),

            # Returns after delay=16 seconds
            loop.run_in_executor(executor, blocking, 16)
        },
        return_when=asyncio.ALL_COMPLETED
    )

loop = asyncio.get_event_loop()
executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
loop.run_until_complete(non_blocking(loop, executor))

（例のように）forループを使用してこれらのタスクをスケジュールする場合、いくつかの異なる戦略がありますが、基本的なアプローチはschedule forループ（またはリスト内包など）を使用するタスクは、asyncio.waitでそれらを待機し、、次に結果を取得します。例：

done, pending = await asyncio.wait(
    fs=[loop.run_in_executor(executor, blocking_foo, *args) for args in inps],
    return_when=asyncio.ALL_COMPLETED
)

# Note that any errors raise during the above will be raised here; to
# handle errors you will need to call task.exception() and check if it
# is not None before calling task.result()
results = [task.result() for task in done]
20
Nick Badger

受け入れられた回答を拡張して、問題の問題を実際に解決します。

注：python 3.7+が必要です

import functools

from urllib.request import urlopen
import asyncio


def legacy_blocking_function():  # You cannot change this function
    r = urlopen("https://example.com")
    return r.read().decode()


def run_in_executor(f):
    @functools.wraps(f)
    def inner(*args, **kwargs):
        loop = asyncio.get_running_loop()
        return loop.run_in_executor(None, lambda: f(*args, **kwargs))

    return inner


@run_in_executor
def foo(arg):  # Your wrapper for async use
    resp = legacy_blocking_function()
    return f"{arg}{len(resp)}"


@run_in_executor
def bar(arg):  # Another wrapper
    resp = legacy_blocking_function()
    return f"{len(resp)}{arg}"


async def process_input(inp):  # Modern async function (coroutine)
    res = await foo(inp)
    res = f"XXX{res}XXX"
    return await bar(res)


async def main():
    inputs = ["one", "two", "three"]
    input_tasks = [asyncio.create_task(process_input(inp)) for inp in inputs]
    print([await t for t in asyncio.as_completed(input_tasks)])
    # This doesn't work as expected :(
    # print([await t for t in asyncio.as_completed([process_input(inp) for inp in input_tasks])])


if __name__ == '__main__':
asyncio.run(main())

この例の最新バージョンとプルリクエストを送信するには、 ここ をクリックします。

8
balki
import asyncio
from time import sleep
import logging

logging.basicConfig(
    level=logging.DEBUG, format="%(asctime)s %(thread)s %(funcName)s %(message)s")


def long_task(t):
    """Simulate long IO bound task."""
    logging.info("2. t: %s", t)
    sleep(t)
    logging.info("4. t: %s", t)
    return t ** 2


async def main():
    loop = asyncio.get_running_loop()
    inputs = range(1, 5)
    logging.info("1.")
    futures = [loop.run_in_executor(None, long_task, i) for i in inputs]
    logging.info("3.")
    results = await asyncio.gather(*futures)
    logging.info("5.")
    for (i, result) in Zip(inputs, results):
        logging.info("6. Result: %s, %s", i, result)


if __name__ == "__main__":
    asyncio.run(main())

出力：

2020-03-18 17:13:07,523 23964 main 1.
2020-03-18 17:13:07,524 5008 long_task 2. t: 1
2020-03-18 17:13:07,525 21232 long_task 2. t: 2
2020-03-18 17:13:07,525 22048 long_task 2. t: 3
2020-03-18 17:13:07,526 25588 long_task 2. t: 4
2020-03-18 17:13:07,526 23964 main 3.
2020-03-18 17:13:08,526 5008 long_task 4. t: 1
2020-03-18 17:13:09,526 21232 long_task 4. t: 2
2020-03-18 17:13:10,527 22048 long_task 4. t: 3
2020-03-18 17:13:11,527 25588 long_task 4. t: 4
2020-03-18 17:13:11,527 23964 main 5.
2020-03-18 17:13:11,528 23964 main 6. Result: 1, 1
2020-03-18 17:13:11,528 23964 main 6. Result: 2, 4
2020-03-18 17:13:11,529 23964 main 6. Result: 3, 9
2020-03-18 17:13:11,529 23964 main 6. Result: 4, 16
0
Vlad Bezden