Summary  
This chapter covers process-based parallelism in Python using the multiprocessing module: creating, starting, and joining processes, along with interprocess communication through queues.  

General domain of usage  
CPU-bound tasks such as data crunching

Picture your Python process as a restaurant franchise, not just a single kitchen. In multiprocessing, you don't just hire more chefs for one kitchen—you actually open several kitchens in different buildings. Each kitchen (process) has its own chef, fridge, stove, and even its own 'Master Knife'—there's no sharing. This means Chef A in Kitchen A and Chef B in Kitchen B can both chop, cook, and serve at the same time, truly in parallel, because they're not waiting for a shared resource like the GIL in threading.

This is the core advantage of multiprocessing: each process runs in its own memory space, so they never bump into each other. It's perfect for heavy tasks such as mathematical calculations, image processing, or data crunching, where real parallelism can speed things up dramatically.

However, if Chef A in Kitchen A needs to pass an ingredient to Chef B in Kitchen B, it's not as easy as just handing it over the counter. They need a delivery truck—this is Inter-Process Communication (IPC). IPC is slow and expensive compared to sharing ingredients in the same kitchen, so you should only use it when necessary.

Let's see how this looks in Python using the multiprocessing module. First, you'll see how to launch two processes that each perform a task in parallel:

```python
from multiprocessing import Process
import time

def print_numbers(name):
    for i in range(1, 4):
        print(f"Process {name}: {i}")
        time.sleep(0.5)

# Create process objects
p1 = Process(target=print_numbers, args=("A",))
p2 = Process(target=print_numbers, args=("B",))
```

Each process is like a chef in their own kitchen. Next, start and join the processes:

```python
p1.start()
p2.start()

p1.join()
p2.join()

print("Both processes have finished.")
```

The output will show both processes running in parallel, with their print statements interleaved. This is true parallelism—each process is independent and can use the CPU at the same time.

But what if you need to share data? You must use special tools, like queues or pipes, which act like delivery trucks between kitchens. Here's how to use a queue for IPC:

```python
from multiprocessing import Process, Queue

def worker(q):
    q.put('Ingredient from worker')

queue = Queue()
p = Process(target=worker, args=(queue,))
p.start()
print(queue.get())
p.join()
```

This approach is slower than simply sharing data between threads, so use multiprocessing when you need real parallelism for CPU-heavy tasks, and keep communication between processes to a minimum. 



Met de **`multiprocessing`**-module van Python kun je **echte paralleliteit** bereiken door afzonderlijke processen te starten, elk met een eigen Python-interpreter en geheugengebied. In tegenstelling tot threads, die geheugen delen en binnen hetzelfde proces draaien, zijn **processen volledig geïsoleerd** van elkaar. Deze isolatie voorkomt de beperking van de **Global Interpreter Lock (GIL)**, waardoor meerdere CPU-kernen parallel kunnen werken aan CPU-intensieve taken. Na het bekijken van de bovenstaande video zou duidelijk moeten zijn dat **parallelisme op basis van processen** vooral nuttig is bij zware berekeningen of wanneer je meerdere kernen wilt benutten voor taken die anders door de GIL zouden worden beperkt. De **`multiprocessing`**-module biedt een vertrouwde API die lijkt op de **`threading`**-module, waardoor het eenvoudig is om afhankelijk van je behoeften te wisselen tussen threading en processing.

Represents an independent process. Use this class to create and manage separate processes.

A process-safe FIFO queue for sharing data between processes. 

Provides a connection between two processes for two-way communication.

Manages a pool of worker processes for parallel execution of a function across data. 

A synchronization primitive for controlling access to shared resources between processes.

Allows sharing a single value of a specific type between processes.

Allows sharing an array of values between processes. 

Creates a server process that holds Python objects and allows other processes to manipulate them using proxies.

Returns a reference to the currently running process object.

Returns the number of CPU cores available on the system.

Gebruik deze klassen en functies om robuuste parallelle applicaties te bouwen, gegevensdeling te beheren en de uitvoering van processen in Python te coördineren.

import multiprocessing
import time

def print_message(message, delay):
    time.sleep(delay)
    print(message)

process1 = multiprocessing.Process(target=print_message, args=("Process 1 finished", 2))
process2 = multiprocessing.Process(target=print_message, args=("Process 2 finished", 1))

process1.start()
process2.start()

process1.join()
process2.join()


Dit codevoorbeeld laat zien hoe je met de **`multiprocessing`**-module van Python taken parallel kunt uitvoeren door aparte processen te creëren. Het voorbeeld gebruikt eenvoudige tijdvertragingen en print berichten om te tonen hoe processen onafhankelijk en gelijktijdig kunnen worden uitgevoerd.

#### Belangrijkste geïllustreerde concepten

- **Procescreatie:**
  - Nieuwe processen worden aangemaakt met de `multiprocessing.Process`-klasse;
  - Elk proces krijgt een doelfunctie (`print_message`) en argumenten die aan die functie worden doorgegeven.

- **Proces starten:**
  - De `start()`-methode start elk proces, waardoor ze gelijktijdig kunnen draaien;
  - Na het starten voert elk proces zijn doelfunctie onafhankelijk van de andere uit.

- **Parallelle uitvoering:**
  - Beide processen slapen voor verschillende duur (`2` en `1` seconden) met `time.sleep()`;
  - Omdat ze parallel draaien, is het proces met de kortste vertraging als eerste klaar, zelfs als het later is gestart.

- **Proces samenvoegen:**
  - De `join()`-methode zorgt ervoor dat het hoofdprogramma wacht tot beide processen klaar zijn voordat het verdergaat;
  - Zonder `join()` zou het hoofdprogramma kunnen afsluiten voordat de processen zijn voltooid.

Dit voorbeeld toont aan dat met multiprocessing taken gelijktijdig op meerdere CPU-kernen kunnen draaien, wat ideaal is voor CPU-intensieve operaties die profiteren van parallelle uitvoering.

Welke uitspraak beschrijft het verschil tussen threads en processen in Python het beste?

Je verwerft praktische vaardigheden in het gebruik van Python-modules en imports voor efficiënt codebeheer. Beheers geavanceerde foutafhandelings­technieken voor betrouwbaardere applicaties, automatiseer bestandsbewerkingen met bestandsafhandeling en leer robuuste teststrategieën met Pytest en Unittest om de integriteit van je code te waarborgen.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Werken met Processen

Belangrijkste geïllustreerde concepten