An Introduction to Concurrency in Python

One way to significantly improve the speed of your Python programs is to use concurrency. Concurrency maximizes the use of your system's resources by enabling the completion of several operations at once. Python has many ways and modules to accomplish concurrency, including threading, multiprocessing, and asynchronous programming. This article will explain what Python concurrency is, how to implement it, provide some excellent examples, and discuss the output.

Understanding the Concurrent programming

It speaks to the computer's capacity to handle several tasks at once. These tasks may be performed in overlapping periods or interspersed; they do not need to be completed at precisely the same time. Handling numerous user inputs, managing several I/O operations, or processing many separate tasks are the major objectives of concurrency.

What is Parallelism?

Concurrency is a subset of parallelism, which is the simultaneous execution of tasks or processes. While parallelism is the simultaneous execution of tasks to speed up computing, concurrency is the handling of many tasks. Enhancing computing efficiency and accelerating system performance is the main objective.

• Thread-Based Concurrency: Threading creates lightweight threads, commonly referred to as "worker threads," all at once. These threads are perfect for I/O-bound tasks since they share the same memory space.
• Process-Based Concurrency: Executing many processes, each with its own memory space, is known as multiprocessing. This is suitable for CPU-bound tasks since it can employ many CPU cores.
• Coroutine-Based Concurrency: The "asyncio," "async," and "await" keywords in asynchronous programming are perfect for effectively controlling I/O-bound processes. During I/O operations, it allows tasks to halt and transfer control to other tasks without crashing the entire programme.

Concurrency vs. Parallelism

Concurrency: It describes the completion of several activities during overlapping periods-though not always simultaneously. It is suitable for processes that are I/O-bound and regularly depend on outside resources like files or network data.

Parallelism: However, it uses many CPU cores to perform numerous applications concurrently. It works well for lengthy processing tasks involving a lot of CPU power.

Steps to Implement Concurrency in Python

• Choose the Right Strategy: Find out if your software is limited by CPU or I/O. Multiprocessing works well for CPU-bound tasks, whereas threading is appropriate for I/O-bound operations.
• Import the Corresponding Libraries: Depending on your approach, import the asyncio, threading, or multiprocessing libraries.
• Establish Worker Roles: Specify the procedures or functions that stand in for the jobs you wish to execute in parallel.
• Construct Threads, Processes, and Tasks: You can start and construct threads, processes, or asynchronous tasks to carry out your worker functions in parallel.
• Control Synchronisation: To avoid data corruption in shared resources while using threads or processes, utilize synchronization techniques like locks or semaphores.
• Await the completion of the job: Ensure that your primary application waits for the completion of all ongoing tasks before proceeding.

Examples of Concurrency in Python

Thread-Based Concurrency

Import the threading and time modules. There are two routines, count_down and print_colors, that mimic laborious tasks. These functions produce countdown numbers and colors with a 1-second interval between prints to simulate a laborious activity. Make two Thread objects, thread_a and thread_b, and assign each to the count_down or print_colors function using the target parameter. To get both threads going, use the start() method. This initiates the functions' parallel execution. To make sure that the main thread waits for threads thread_a and thread_b to finish before proceeding, use the join() function for each thread. This synchronization stage is necessary to prevent the main program from finishing too soon. Print a message at the end stating that all threads have completed.

Output:

 Counting down: 1 Printing color: Red Counting down: 2Printing color: Blue Printing color: Green Counting down: 3 All threads have completed. 

Explanation:

To perform count_down and print_colors concurrently, the code generates two threads. Every function mimics a task where there is a one-second pause between each operation. Join() is used by the main thread to wait for both threads to finish before reporting "All threads have completed."

Process-Based Concurrency

The program demonstrates the ability to cube a number using the cube(n) function. If the main process is run, a list of values [6, 7, 8, 9, 10] is defined. A pool of multiple processors is created using multiprocessing.Pool(). The cube function is applied to each value in parallel using the map() method, dividing the task among the processes. Finally, the output is printed.

Output:

 [216, 343, 512, 729, 1000] 

Explanation:

This code parallelises the computation of cubing numbers from a list (values) by utilising the multiprocessing module. The map technique is used to apply the cube function concurrently to all values in the list while creating a pool of worker processes. Collecting and printing the results shows how parallel processing may speed up calculation.

Coroutine-Based Concurrency (using asyncio)

The following is a breakdown of the code: Import the asyncio module to program in an asynchronous manner. asyncio await is used. The asynchronous function say_hello(word), defined with await asyncio.sleep(1), simulates a greeting with a one-second delay. Describe the run_tasks() asynchronous function. Use asyncio.gather() to schedule the say_hello function for each name simultaneously. In the case when __name__ == "__main__", execute the main asynchronous function using asyncio by using asyncio.run(run_tasks()).

Output:

 Java T Point 

Explanation:

Upon running this code, you will observe that the say_hello function prints each word after waiting one second. Since asyncio.gather() schedules all calls to say_hello concurrently, the greetings "Java," "T," and "Point" will be printed almost simultaneously after a one-second delay, demonstrating Python's non-blocking asynchronous programming.

Finally, adding parallelism to your Python programs may significantly increase their speed, regardless of whether they are CPU-or I/O-bound. The right approach and libraries like asyncio, threading, and multiprocessing can make Python programs more responsive and efficient.