How to use asyncio with existing blocking library?
Question:
I have few blocking functions foo, bar and I can’t change those (Some internal library I don’t control. Talks to one or more network services). How do I use it as async?. E.g. I wan’t to do the following.
results = []
for inp in inps:
val = foo(inp)
result = bar(val)
results.append(result)
This will be inefficient as I can call foo for the second input while I am waiting for the first and same for bar. How do I wrap them such that they are usable with asyncio (i.e new async, await syntax)?
Lets assume the functions are re-entrant. i.e it is fine to call foo again when already a previous foo is processing.
Update
Extending answer with reusable decorator. Click here for example.
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
Answers:
There are (sort of) two questions here:
- how can I run blocking code asynchronously within a coroutine
- how can I run multiple async tasks at the "same" time (as an aside: asyncio is single-threaded, so it is concurrent, but not truly parallel).
Concurrent tasks can be created using the high-level asyncio.create_task or the low-level asyncio.ensure_future. Starting with 3.11, they can also be created through asyncio task groups, as pioneered by the Trio library (the creator of Trio has an excellent blog post on the subject here).
To run synchronous code, you will need to run the blocking code in an executor. Example:
import concurrent.futures
import asyncio
import time
def blocking(delay):
time.sleep(delay)
print('Completed.')
async def non_blocking(executor):
loop = asyncio.get_running_loop()
# 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
)
executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
asyncio.run(non_blocking(executor))
If you want to schedule these tasks using a for loop (as in your example), you have several different strategies, but the underlying approach is to schedule the tasks using the for loop (or list comprehension, etc), await them with asyncio.wait, and then retrieve the results. Example:
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]
Extending the accepted answer to actually solve the problem in question.
Note: Requires 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())
Click here for up to date version of this example and to send pull requests.
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())
Output:
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
Now you can also just use asyncio.to_thread to asynchronously run function in a separate thread.
import asyncio
import time
def blocking():
print("Started!")
time.sleep(5)
print("Finished!")
async def non_blocking():
print("Started!")
await asyncio.sleep(5)
print("Finished!")
async def main():
print("Blocking function:")
start_time = time.time()
await asyncio.gather(*(asyncio.to_thread(blocking) for i in range(5)))
print("--- %s seconds ---" % (time.time() - start_time))
print("Non-blocking function:")
start_time = time.time()
await asyncio.gather(*(non_blocking() for i in range(5)))
print("--- %s seconds ---" % (time.time() - start_time))
asyncio.run(main())
Output:
Blocking function:
Started!
Started!
Started!
Started!
Started!
Finished!
Finished!
Finished!
Finished!
Finished!
--- 5.018239736557007 seconds ---
Non-blocking function:
Started!
Started!
Started!
Started!
Started!
Finished!
Finished!
Finished!
Finished!
Finished!
--- 5.005802392959595 seconds ---
Documentation: https://docs.python.org/3.11/library/asyncio-task.html#asyncio.to_thread
I have few blocking functions foo, bar and I can’t change those (Some internal library I don’t control. Talks to one or more network services). How do I use it as async?. E.g. I wan’t to do the following.
results = []
for inp in inps:
val = foo(inp)
result = bar(val)
results.append(result)
This will be inefficient as I can call foo for the second input while I am waiting for the first and same for bar. How do I wrap them such that they are usable with asyncio (i.e new async, await syntax)?
Lets assume the functions are re-entrant. i.e it is fine to call foo again when already a previous foo is processing.
Update
Extending answer with reusable decorator. Click here for example.
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
There are (sort of) two questions here:
- how can I run blocking code asynchronously within a coroutine
- how can I run multiple async tasks at the "same" time (as an aside: asyncio is single-threaded, so it is concurrent, but not truly parallel).
Concurrent tasks can be created using the high-level asyncio.create_task or the low-level asyncio.ensure_future. Starting with 3.11, they can also be created through asyncio task groups, as pioneered by the Trio library (the creator of Trio has an excellent blog post on the subject here).
To run synchronous code, you will need to run the blocking code in an executor. Example:
import concurrent.futures
import asyncio
import time
def blocking(delay):
time.sleep(delay)
print('Completed.')
async def non_blocking(executor):
loop = asyncio.get_running_loop()
# 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
)
executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
asyncio.run(non_blocking(executor))
If you want to schedule these tasks using a for loop (as in your example), you have several different strategies, but the underlying approach is to schedule the tasks using the for loop (or list comprehension, etc), await them with asyncio.wait, and then retrieve the results. Example:
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]
Extending the accepted answer to actually solve the problem in question.
Note: Requires 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())
Click here for up to date version of this example and to send pull requests.
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())
Output:
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
Now you can also just use asyncio.to_thread to asynchronously run function in a separate thread.
import asyncio
import time
def blocking():
print("Started!")
time.sleep(5)
print("Finished!")
async def non_blocking():
print("Started!")
await asyncio.sleep(5)
print("Finished!")
async def main():
print("Blocking function:")
start_time = time.time()
await asyncio.gather(*(asyncio.to_thread(blocking) for i in range(5)))
print("--- %s seconds ---" % (time.time() - start_time))
print("Non-blocking function:")
start_time = time.time()
await asyncio.gather(*(non_blocking() for i in range(5)))
print("--- %s seconds ---" % (time.time() - start_time))
asyncio.run(main())
Output:
Blocking function:
Started!
Started!
Started!
Started!
Started!
Finished!
Finished!
Finished!
Finished!
Finished!
--- 5.018239736557007 seconds ---
Non-blocking function:
Started!
Started!
Started!
Started!
Started!
Finished!
Finished!
Finished!
Finished!
Finished!
--- 5.005802392959595 seconds ---
Documentation: https://docs.python.org/3.11/library/asyncio-task.html#asyncio.to_thread