Скачать или смотреть Fetching Results from a Blocking Function in Python Asyncio

Discover how to effectively manage blocking functions in Python's asyncio to seamlessly await results, while still allowing other asynchronous tasks to run.
---
This video is based on the question https://stackoverflow.com/q/64068063/ asked by the user 'string' ( https://stackoverflow.com/u/12751366/ ) and on the answer https://stackoverflow.com/a/64068470/ provided by the user 'user4815162342' ( https://stackoverflow.com/u/1600898/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How do I get results from the blocking function?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Fetching Results from a Blocking Function in Python Asyncio

When diving into the world of asynchronous programming in Python using the asyncio library, many developers often face a common challenge: how to handle blocking functions. A frequent query is how to get results from a blocking function while simultaneously running other asynchronous operations. In this guide, we will tackle this exact problem with an illustrative example.

Understanding the Problem

Let’s begin by understanding our starting point. We have a blocking function abab() that performs some operations and takes time to complete. In our specific example, this function simply prints numbers from 0 to 9, with a 1-second pause between each print, ultimately returning the value 10000.

Parallel to this operation, we have an async function ab() that repeatedly prints 111 every second while our abab() function is running.

The crux of the issue is that even though abab() is blocking, we want to continue executing ab() and then capture the result from abab() once it finishes. However, the initial code structure does not allow this, and we want to achieve the following print sequence:

[[See Video to Reveal this Text or Code Snippet]]

Instead of the previous sequence which didn't include the 10000 result in the desired location.

The Solution

The good news is that there is a straightforward solution to this problem. By utilizing the run_in_executor method, we can effectively await the return value of our blocking function. Let’s break down the solution step-by-step.

Step 1: Modify the Asynchronous Main Function

We will be making a small but crucial change to the main() function where we manage tasks.

Full Code Implementation

Here is how the updated code looks:

[[See Video to Reveal this Text or Code Snippet]]

Explanation of the Code Changes

Task Creation:

We use asyncio.create_task(ab()) to run the ab() function in the background.

First Await:

By calling run_in_executor(None, abab), we submit our blocking function abab() to be executed in a separate thread. This allows our program to continue operating without being halted by the blocking function.

Capturing the Result:

The line abab_result = await loop.run_in_executor(None, abab) allows us to capture the result of the abab() function. Once it completes, the return value 10000 will be stored in abab_result.

Printing the Result:

Finally, we print abab_result, which outputs 10000 at the right moment within our print sequence.

Conclusion

By leveraging asyncio and run_in_executor, you can manage blocking functions in Python without breaking the flow of your asynchronous tasks. This approach preserves the responsiveness of your application while ensuring that results from blocking functions are obtained seamlessly.

With this understanding, you can now tackle blocking function issues with confidence in your asynchronous Python projects!