Python Multiprocessing Tutorial – Complete Guide

In this digital age, where everything is increasingly dependent on computers and automation, Python’s multiprocessing enlists the help of your computer’s multiple cores to make your software work more efficiently. Not only does this boost performance but it allows the development of games, apps and AI systems with enhanced functionality.

What is Python Multiprocessing?

Python’s multiprocessing module is a powerful tool that allows you to create and manage multiple processes simultaneously. Each process runs independently, and they can execute different tasks concurrently, maximizing the computing power of your machine.

Why Is It Beneficial?

Considering the rapid pace of technological advancement, knowledge of Python multiprocessing can be a game-changer. Here’s why:

  • Performance Boost: By dividing tasks among different cores, you can dramatically speed up the execution time of your code.
  • Resource Utilization: Multiprocessing enables optimal utilization of available system resources.
  • Versatility: Many real-world applications like game development, data analysis, AI and machine learning make use of multiprocessing to level up their capabilities.

Should I Learn It?

The answer is a resounding yes! Python multiprocessing not only broadens your coding skillset but also increases your employability in fields such as game development and AI. Understanding this concept allows you to develop software with improved efficiency and performance.

CTA Small Image
FREE COURSES AT ZENVA
LEARN GAME DEVELOPMENT, PYTHON AND MORE
ACCESS FOR FREE
AVAILABLE FOR A LIMITED TIME ONLY

Python Multiprocessing – Basic Examples

Before we begin, always start by importing the `multiprocessing` module in every Python script you intend to use multiprocessing.

import multiprocessing

Example 1 – Creating a Simple Process

Creating a new process is simple with Python. You just need to define a function that represents the task to be performed, and then create a Process object to run it.

import multiprocessing

def print_hello():
  print('Hello, from a separate process!')

process = multiprocessing.Process(target=print_hello)
process.start()  # Start the process
process.join()   # Wait for the process to finish

In the code above, we create a process that calls the `print_hello` function.

Example 2 – Running Multiple Processes

Multiple processes can be started and managed by using a list. Let’s create an array of processes:

import multiprocessing

def print_num(num):
  print('Number: ', num)

processes = [multiprocessing.Process(target=print_num, args=(i,)) for i in range(5)]

# Start all processes
for process in processes:
    process.start()

# Wait for all processes to finish
for process in processes:
    process.join()

In this example, we use a list comprehension to create a list of five processes, each of which prints a number from 0 to 4.

Example 3 – Use of `Pool`

A process `Pool` object controls a pool of worker processes to which jobs can be submitted, this comes in handy when you need to limit the number of running processes.

import multiprocessing

def square(n):
  return n * n

with multiprocessing.Pool() as pool:
  results = pool.map(square, range(10))
  print(results)

Here we’ve used `multiprocessing.Pool().map()` to map the function `square()` onto the array of numbers from 0 to 9, each running in its own process. The results are collected into a list.

Example 4 – Sharing Data Between Processes

To share data between processes, `multiprocessing` provides a `Value` or `Array`. For more complex data types, we can use the `Manager` class:

from multiprocessing import Process, Value, Array, Manager

def work(num, arr, dict):
    num.value = 88
    arr[0] = 22
    dict[1] = "World!"

if __name__ == '__main__':
    number = Value('i', 0)
    array = Array('i', range(10))
    with Manager() as manager:
        dict = manager.dict({1:"Hello", 2:"!"})
        process = Process(target=work, args=(number, array, dict))
        process.start()
        process.join()
        print(number.value)
        print(array[:])
        print(dict)

In this example, we’ve used `Value`, `Array`, and `Manager` to share data between processes.

Example 5 – Communication Between Processes

`multiprocessing` provides two types of communication channel for processes – `Queue` and `Pipe`.

from multiprocessing import Process, Queue

def process_one(queue):
    queue.put('Hello')

def process_two(queue):
    msg = queue.get()
    print('Received:', msg)

if __name__ == "__main__":
    queue = Queue()
    process1 = Process(target=process_one, args=(queue,))
    process2 = Process(target=process_two, args=(queue,))

    process1.start()
    process2.start()

    process1.join()
    process2.join()

In this code, process one sends a `Hello` message to process two using the `Queue` as communication channel.

Example 6 – Synchronization of Processes

`multiprocessing` also provides methods to synchronize processes using `Lock` and `Semaphore`.

from multiprocessing import Process, Lock

def worker(lock, num):
    lock.acquire()
    try:
        print('Hello', num)
    finally:
        lock.release()

if __name__ == '__main__':
    lock = Lock()

    for num in range(10):
        Process(target=worker, args=(lock, num)).start()

This script uses `Lock` to ensure that only a single process can access a resource at a time.

Example 7 – Using Process Pools

`multiprocessing.Pool` creates a pool of worker processes. It offers methods like `map`, `apply` to offload tasks to the worker processes.

from multiprocessing import Pool

def square(n):
    return n * n

if __name__ == "__main__":
    with Pool(5) as p:
        print(p.map(square, [1, 2, 3, 4, 5]))

Pool of 5 worker processes is created, they receive tasks to square numbers 1 through 5. The result is returned as a list.

Where to Go Next?

Learning how to code is a journey, and we are here at Zenva to empower you on that journey. With over 250 courses available, spanning a wide range of topics from programming to AI game development, Zenva is ready to guide you from beginner to professional.

One of our best resources for continuing your journey with Python and multiprocessing is the Python Mini-Degree. Our Python Mini-Degree offers an all-inclusive learning experience. Covering all the way from the basics, like coding and algorithms, to more intricate concepts such as game and app development with popular libraries and frameworks like PyGame, Tkinter, and Kivy, we have developed our courses to cater to all learners, whether you’re just getting started or seeking to expand your knowledge.

The curriculum includes an array of projects designed to give you hands-on experience. You’ll learn by doing as you build games, a medical diagnosis bot, and more real-world applications. After all, Python is a highly popular language widely used across different industries – learning it is indeed a great investment in your future.

Moreover, our courses offer the flexibility of learning at your own pace, with live coding and quiz options that reinforce your learning. Armed with a portfolio full of Python projects and completion certificates, you will be ready to take on diverse coding challenges.

Looking to expand your Python skills in a different direction? Zenva offers a wide array of Python courses to help you focus on building the skills you require the most.

Conclusion

Stepping into the world of Python and multiprocess programming opens up a powerhouse of possibilities. From scripting simple tasks to building high-performing games and AI systems, the knowledge of multiprocessing can be pivotal to your programming journey. Our Python Mini-Degree is perfectly suited to guide you in mastering this influential language, equipping you with skills that are highly sought after in today’s job market.

At Zenva, we believe in the power of learning through doing. With our Python courses, you’re not just learning; you’re also creating. You’re developing projects, expanding your portfolio and evolving into a skilled Python programmer. Don’t wait – unlock the door to your future with us today.

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

FREE COURSES
Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.