Скачать или смотреть Understanding the ThreadPoolExecutor Issue: Why submit() Returns a TypeError

Explore why using `ThreadPoolExecutor` in Python leads to unexpected exceptions and how to fix them with clear examples and explanations.
---
This video is based on the question https://stackoverflow.com/q/65214357/ asked by the user 'compuTE' ( https://stackoverflow.com/u/8051307/ ) and on the answer https://stackoverflow.com/a/65214444/ provided by the user 'alex_noname' ( https://stackoverflow.com/u/13782669/ ) 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: ThreadPoolExecutor executor.submit() returns an exception which is not raised without it

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.
---
Understanding the ThreadPoolExecutor Issue: Why submit() Returns a TypeError

When working with Python's threading capabilities, specifically the ThreadPoolExecutor from the concurrent.futures module, you may encounter an unexpected exception that manifests when using the submit() method. This can be frustrating, especially when the behavior seems to differ from executing the code without threads. In this guide, we will dissect the problem, clarify what’s going wrong, and provide a working solution to the error you might encounter.

The Problem at Hand

In the initial example, the author noted a TypeError when trying to call the result() method of futures created using executor.submit(). The peculiar thing is that this exception does not occur when running the function directly without using threading. Here's a quick breakdown of the encountered error during the execution:

Initial Error: The print([i.result for i in cats_results]) used in the code does not actually call result, leading to a list of bound methods rather than the intended outputs.

Second Error: Changing this to print([i.result() for i in cats_results]) leads to a TypeError: 'str' object is not callable, as the method wasn't referenced correctly when submitting the function to the executor.

Understanding Why This Happens

The root cause of these problems lies in how the method is submitted to the ThreadPoolExecutor. When you call:

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

You are actually calling the sayname method immediately instead of passing the method itself to be executed. This means that the executor.submit() is receiving the return value (a string) instead of the function to execute, thus leading to the TypeError.

The Solution

To fix the encountered issues, we need to ensure that we correctly pass the method reference without calling it immediately. Here’s the corrected version of your code:

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

Key Changes Explained

Change in Submission: Replace executor.submit(i.sayname()) with executor.submit(i.sayname). By omitting the parentheses on sayname, we are now correctly passing the method as a callable to the executor.

Properly Calling result(): The fix means that the call to result() on the futures will work as intended, allowing you to retrieve the string outputs as expected.

Expected Output

When you run the modified code, you should see the correct output:

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

Conclusion

Understanding how to properly use the ThreadPoolExecutor and avoiding common pitfalls like submitting methods incorrectly can save you a lot of frustration when working with multithreading in Python. Always remember to pass method references without calling them prematurely to avoid unexpected behaviors and exceptions.

With this knowledge, you're better equipped to handle threading in Python and can delve into more advanced concurrent programming techniques with confidence. Happy coding!