Click here for the first post, which contains the context of this series.
Item #56: Know how to recognize when concurrency is necessary.
In this item, the author creates Conway's Game of Life and asks about its scalability in the context of a MMO. He summarizes it as follows: "Python provides many built-in tools for achieving fan-out and fan-in with various trade-offs. You should understand the pros and cons of each approach and choose the best tool for the job, depending on the situation."
Item #57: Avoid creating new Thread instances for on-demand fan-out.
Consider Conway's Game of Life, mentioned in the previous item, and suppose that you create a Thread instance for each cell. This will work, but there are tradeoffs:- Thread instances require special tools (like Lock) to coordinate among themselves.
- Each Thread instance requires about 8 MB, which is high.
- Starting a Thread instance and their subsequent context switching is costly.
- Thread instances do not provide a built-in way to re-raise exceptions back to their callers.
- Thread instances require special tools (like Lock) to coordinate among themselves.
- Each Thread instance requires about 8 MB, which is high.
- Starting a Thread instance and their subsequent context switching is costly.
- Thread instances do not provide a built-in way to re-raise exceptions back to their callers.
Item #58: Understand how using Queue for concurrency requires refactoring.
In this item, the author refactors Conway's Game of Life from the previous item in an attempt to showcase the difficulty of using Queue. He summarizes it as follows:- Using Queue instances with a fixed number of Thread instances improves the scalability of fan-in and fan-out.
- It is difficult to refactor existing code to use Queue.
- Using Queue has a fundamental limit to the total amount of I/O parallelism.
- Using Queue instances with a fixed number of Thread instances improves the scalability of fan-in and fan-out.
- It is difficult to refactor existing code to use Queue.
- Using Queue has a fundamental limit to the total amount of I/O parallelism.
Item #59: Consider ThreadPoolExecutor when threads are necessary for concurrency.
In this item, the author uses ThreadPoolExecutor from concurrent.futures to address Conway's Game of Life from the previous items. It takes the best of both the previously discussed worlds (Thread and Queue) without the boilerplate. Nevertheless, it still does not scale well in terms of fan-out.
Item #60: Achieve highly concurrent I/O with coroutines.
In this item, the author introduces the keywords async and await, introduces the built-in library asyncio, and uses them to address Conway's Game of Life in an incredibly optimal way. Here is a simple code snippet that illustrates their use:
import asyncioasync def blocking_io(i): await asyncio.sleep(1) return f'My ID is {i} and I waited 1 second.'async def func(): results = [] for i in range(10): results.append(blocking_io(i)) return await asyncio.gather(*results)print(asyncio.run(func()))
import asyncio
async def blocking_io(i):
await asyncio.sleep(1)
return f'My ID is {i} and I waited 1 second.'
async def func():
results = []
for i in range(10):
results.append(blocking_io(i))
return await asyncio.gather(*results)
print(asyncio.run(func()))