In this chapter we will show different solutions to a common problem. To run the code, which is available in the Chapter02 folder of the Github repo at https://github.com/PacktPublishing/Asynchronous-Programming-in-Python, we recommend creating a new virtual environment inside the folder and then running each Python file to check its output. No external packages are required but this way you can isolate your execution from the common Python environment of your computer:

$ python3 -m venv .env
$ source .env/bin/activate

Concurrency refers to the number of simultaneous tasks a system executes. Computers’ processors execute atomic operations at amazing speed, but they execute them one at a time. The result is that it looks like they are executing non-atomic tasks simultaneously.

To illustrate the idea, the following diagram shows two programs, each of which consists of three atomic operations: a processing task, reading a long file, and finally, another processing task:

Figure 2.1: Two concurrent programs being executed by a single processor

Imagine that both programs are launched at the same time. The processor executes the first atomic task of one of them and when there is a blocking operation that depends on a resource other than the processing unit, it uses the interruption mechanism to execute the first task of the second program. Both programs are executed concurrently by the processor.

Python offers several mechanisms to handle...

Applying multiprocessing or multithreading techniques to any code isn’t a good choice; concurrency and parallelism are best reserved for the problem spaces where they provide the best results. As a rule of thumb, if a problem is input- or output-bound, it is better suited to being solved by increasing the concurrency handling of the system. If the problem requires more processing than data management, it is CPU-bound, and then multiprocessing is the best approach.

Usually, however, it is not that simple. Distributed systems, with their reliance on network communication, inherently have I/O characteristics that make them more suitable for the application of concurrency management techniques, while some of the components of the distributed systems could use the power of local/distributed processors to accelerate execution (e.g. when a specific large task is distributed across multiple parallel processors with a framework like MapReduce...

Applying a simple function over a loop is a good example of a so-called embarrassingly parallel workload, which means that an easy optimization that can result in improved performance is to use multithreading or multiprocessing techniques to speed up the calculations. More broadly, the basic criterion you should check before trying to implement a parallelization optimization is that the sub-units of work making up your task are completely independent. In the previous example, the distance calculation for cities A and B is completely independent of the B to C case. You can find a simple example of an embarrassingly parallel workload in the repository file Chapter 2/embarrassingly.py, the code being a simple math operation:

import time
import multiprocessing
def square_number(n):
    time.sleep(0.001)
    return n * n
def serial_square_list(numbers):
    return [square_number(n) for n in numbers]
def parallel_square_list(numbers, num_processes...

In this chapter we have explored the basics of multiprocessing/multithreading applied to a classic embarrassingly parallel problem to discover that the apparently complicated calculations were less of an overhead than the context-switching cost of the parallelization techniques. Then, we discussed the importance of testing thread safety when you work with the threading module or similar. Finally, some of the most interesting well-known problems for which parallelization could offer benefits were mentioned. With these tools, you should be able to evaluate whether a workload is a good fit for the application of such kinds of optimization.

The next chapter will go deeper into practice with the implementation of simple solutions that take advantage of Python’s cooperative multitasking capabilities: generators and coroutines will be used to improve vanilla solutions for a CPU-intensive problem. Those tools, along with those discussed here, form the basis for understanding...