Python Multiprocessing Exercises

While multithreading is great for I/O-bound tasks, it doesn’t offer true parallelism in Python due to the Global Interpreter Lock (GIL). For CPU-bound tasks, where you need real concurrent processing across multiple cores, Python provides the `multiprocessing` module, which spawns separate processes — each with its own memory space and Python interpreter.

This enables Python programs to fully utilize multiple CPU cores, making it ideal for tasks like data processing, mathematical computation, image manipulation, and other heavy CPU operations.

Consider the following code:

import multiprocessing
import time

def square_numbers():
    for i in range(5):
        print(f"Squaring {i}: {i ** 2}")
        time.sleep(1)

if __name__ == "__main__":
    p1 = multiprocessing.Process(target=square_numbers)
    p2 = multiprocessing.Process(target=square_numbers)

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print("Main process finished.")

What does this code demonstrate about multiprocessing in Python?

It runs two functions sequentially, one after the other.

It creates two threads that share memory and execute the same function.

It runs the same function in two separate processes, enabling true parallel execution.

It runs both processes in the same interpreter thread, which blocks one after another.

This code uses the multiprocessing module to create two separate processes that each execute the square_numbers() function:

Each process runs in its own Python interpreter and memory space.
p1.start() and p2.start() run both processes in parallel.
p1.join() and p2.join() ensure the main program waits until both processes finish.
Because each process is isolated, they can run truly in parallel, taking full advantage of multi-core CPUs.

This is a powerful technique for speeding up CPU-intensive tasks, and unlike threads, processes don’t share memory, reducing the risk of race conditions but increasing inter-process communication overhead.

Python’s multiprocessing module is essential for building efficient data pipelines, parallel processors, and heavy-computation programs.

Which Python module provides built-in support for multiprocessing?

threading

subprocess

multiprocessing

concurrent.futures.thread

The multiprocessing module provides support for process-based parallelism. It allows you to create and manage separate Python processes, taking advantage of multiple CPU cores — unlike threading, which is limited by the Global Interpreter Lock (GIL).

What does the `Process` class in the `multiprocessing` module represent?

A thread within the main process.

A separate process running independently from the main process.

A coroutine managed by the event loop.

A subprocess created using the subprocess module.

The Process class represents a separate process that runs independently from the main program, with its own memory space. This enables true parallelism and avoids the limitations of the Global Interpreter Lock (GIL).

Which method starts the process and invokes its `run()` method?

start()

run()

execute()

begin()

Calling start() on a Process object creates a new process and invokes its run() method in that separate process. Calling run() directly runs the code in the current process instead of starting a new one.

What does the following code output?

from multiprocessing import Process

def greet():
    print("Hello from process")

p = Process(target=greet)
p.start()
p.join()

Nothing, because greet is never called.

Prints "Hello from process" once.

Prints "Hello from process" twice.

Raises an exception due to missing arguments.

The greet function is passed as the target of the Process. When p.start() is called, the new process runs greet() and prints the message. p.join() waits for the process to finish before continuing.

Which of the following correctly describes the relationship between processes created using the `multiprocessing` module?

All processes share the same memory space.

Each process has its own independent memory space.

Processes automatically share variables and objects.

Processes communicate via shared global variables by default.

Processes created with the multiprocessing module run in separate memory spaces, unlike threads which share memory. This isolation ensures processes don't interfere but requires explicit inter-process communication (IPC) to share data.

What will the following code output?

from multiprocessing import Process

def worker(num):
    print(f"Worker {num}")

processes = []
for i in range(3):
    p = Process(target=worker, args=(i,))
    processes.append(p)
    p.start()

for p in processes:
    p.join()

Worker 0
Worker 1
Worker 2

Worker 2
Worker 1
Worker 0

The workers may print in any order.

No output because join() stops all processes immediately.

Processes run independently and concurrently, so the print statements can appear in any order. join() waits for processes to complete but does not control the order of execution.

What is the purpose of `multiprocessing.Queue`?

To create new processes.

To lock shared memory between processes.

To synchronize threads within a process.

To safely share data between multiple processes.

multiprocessing.Queue provides a thread- and process-safe FIFO queue for inter-process communication (IPC). It allows different processes to share data safely without corruption or race conditions.

What happens if you call `Process.run()` directly instead of `Process.start()`?

The run() method executes in the current process without creating a new process.

It raises a RuntimeError because the process was not started correctly.

The process starts asynchronously in the background.

It queues the process to be started later.

Calling run() directly executes the target function in the current process, behaving like a normal function call. To start a separate process, you must call start(), which internally calls run() in a new process.

Which method is used to terminate a process before it finishes its task?

join()

terminate()

kill()

stop()

terminate() forcefully stops the process immediately. join() waits for a process to finish. kill() and stop() are not standard methods in Python's multiprocessing.Process.

What will the following code snippet print?

from multiprocessing import Process, current_process

def task():
    print(f"Process name: {current_process().name}")

p = Process(target=task, name="MyProcess")
p.start()
p.join()

Process name: Process-1

Process name: MainProcess

Process name: MyProcess

No output, it raises an error.

You can name a process when creating it with the name parameter. The current_process().name returns this name inside the running process. Here, the process prints "MyProcess".

What is a key difference between `multiprocessing.Pool` and manually managing `Process` objects?

Pool is used only for I/O-bound tasks, while Process is for CPU-bound tasks.

Pool automatically manages process lifecycle and load balancing, whereas with Process you manually start, join, and terminate processes.

Pool does not support parallel execution, but Process does.

Pool provides a convenient API for parallel execution of tasks and manages worker processes internally.

multiprocessing.Pool offers a high-level interface for running tasks in parallel, managing a fixed number of worker processes efficiently. When using Process directly, you have to manage process creation, start, join, and termination manually.

Which of the following best describes how `multiprocessing.Manager` helps with sharing data?

It creates shared memory arrays accessible by all processes without locks.

It provides a server process which manages shared objects and proxies for other processes.

It duplicates all data between processes to avoid race conditions.

It serializes data to disk for inter-process communication.

multiprocessing.Manager creates a server process that holds Python objects and allows other processes to access them via proxies. This allows sharing of complex data types safely between processes, unlike shared memory arrays which only support simple data types.

Consider the following code snippet:

from multiprocessing import Pool

def square(x):
    return x * x

with Pool(processes=3) as pool:
    results = pool.map(square, [1, 2, 3, 4, 5])

print(results)

What will be the output?

[1, 4, 9, 16, 25]

[1, 2, 3, 4, 5]

[None, None, None, None, None]

Raises a TypeError

Pool.map() applies the function to each item in the iterable using the pool of worker processes. The function square returns the square of the input. Hence, the output list contains the squares of [1, 2, 3, 4, 5].

What is the correct way to share a mutable object like a list across multiple processes using `multiprocessing`?

Pass the list as an argument to each process; they will share the same memory.

Use multiprocessing.Lock to protect the list passed to each process.

Use multiprocessing.Manager().list() to create a shared list proxy accessible by all processes.

Use a global variable declared outside all processes.

Each process has its own memory space, so passing a list as an argument creates a copy, not shared memory. multiprocessing.Manager() provides proxy objects like list() that are shared and synchronized across processes. Locks alone don’t share memory.

What will be the output of the following code?

from multiprocessing import Process, Value

def add_10(num):
    num.value += 10

if __name__ == "__main__":
    shared_num = Value('i', 5)
    p = Process(target=add_10, args=(shared_num,))
    p.start()
    p.join()
    print(shared_num.value)

5

15

0

Raises an error because Value cannot be shared.

Value creates a shared object between processes. The add_10 function increments the shared integer value by 10 in the separate process. After joining, the main process prints the updated value, which is 15.

What issue can arise when using the `multiprocessing` module on Windows if you forget to protect the entry point with `if name == "main":`?

The program runs slower due to extra process spawning.

Processes share memory unintentionally, causing data corruption.

A deadlock occurs when processes try to join themselves.

The program crashes or infinitely spawns subprocesses due to recursive process creation.

On Windows, the multiprocessing module starts new processes by importing the main module. Without the if __name__ == "__main__": guard, the process creation code runs recursively, causing infinite subprocess spawning and crashing the program.

Consider the following code snippet using a `Pool` of workers:

from multiprocessing import Pool

def f(x):
    return x*x

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

What is true about this code?

result will be empty because the pool closes immediately.

The Pool context manager properly manages starting and closing workers, ensuring results are collected.

Using with Pool() is not recommended; manual close() and join() are required.

The code will raise an error because f is not picklable.

Using Pool as a context manager automatically starts worker processes, waits for their completion, and closes the pool. It is a clean, recommended way to manage worker pools and ensures results are gathered before exiting.

What will happen if a `multiprocessing.Process` targets a function that returns a value?

The return value is discarded; the process does not return data directly.

The return value is automatically printed.

The return value is accessible via process.result.

An exception is raised because functions must return None.

Functions run in separate processes do not return values directly. To get results, you need to use inter-process communication methods such as Queues, Pipes, or shared memory. The return value is discarded after the function finishes in the child process.

How does `multiprocessing.Queue` differ from `queue.Queue` when used in multiprocessing programs?

They are identical and can be used interchangeably.

multiprocessing.Queue is slower because it uses file locks.

multiprocessing.Queue supports communication between processes, while queue.Queue is only for threads.

queue.Queue supports shared memory between processes by default.

multiprocessing.Queue is designed for inter-process communication, using IPC mechanisms under the hood. queue.Queue is thread-safe but works only within a single process’s threads and does not support cross-process communication.

Python Multiprocessing Exercises

This enables Python programs to fully utilize multiple CPU cores, making it ideal for tasks like data processing, mathematical computation, image manipulation, and other heavy CPU operations.

Consider the following code:

What does this code demonstrate about multiprocessing in Python?

Which Python module provides built-in support for multiprocessing?

What does the Process class in the multiprocessing module represent?

Which method starts the process and invokes its run() method?

What does the following code output?

Which of the following correctly describes the relationship between processes created using the multiprocessing module?

What will the following code output?

What is the purpose of multiprocessing.Queue?

What happens if you call Process.run() directly instead of Process.start()?

Which method is used to terminate a process before it finishes its task?

What will the following code snippet print?

What is a key difference between multiprocessing.Pool and manually managing Process objects?

Which of the following best describes how multiprocessing.Manager helps with sharing data?