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. 



Il modulo **`multiprocessing`** di Python consente di ottenere una **vera parallelizzazione** avviando processi separati, ciascuno con il proprio interprete Python e spazio di memoria. A differenza dei thread, che condividono la memoria e vengono eseguiti nello stesso processo, **i processi sono completamente isolati** l'uno dall'altro. Questo isolamento evita la limitazione del **Global Interpreter Lock (GIL)**, permettendo a più core della CPU di lavorare in parallelo su attività che richiedono molte risorse di calcolo. Dopo aver visto il video sopra, dovresti comprendere che la **parallelizzazione basata sui processi** è particolarmente utile quando è necessario eseguire calcoli intensivi o sfruttare più core per attività che altrimenti sarebbero rallentate dal GIL. Il modulo **`multiprocessing`** offre un'API familiare simile a quella del modulo **`threading`**, facilitando il passaggio tra threading e processing a seconda delle esigenze.

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.

Utilizzo di queste classi e funzioni per costruire applicazioni parallele robuste, gestire la condivisione dei dati e coordinare l'esecuzione dei processi in Python.

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()


Questo esempio di codice dimostra come utilizzare il modulo **`multiprocessing`** di Python per eseguire attività in parallelo creando processi separati. L'esempio utilizza semplici ritardi temporali e stampa messaggi per mostrare come i processi possano essere eseguiti in modo indipendente e simultaneo.

#### Concetti chiave illustrati

- **Creazione dei processi:**
  - Si creano nuovi processi utilizzando la classe `multiprocessing.Process`;
  - A ciascun processo viene assegnata una funzione di destinazione (`print_message`) e gli argomenti da passare a tale funzione.

- **Avvio dei processi:**
  - Il metodo `start()` avvia ciascun processo, consentendo loro di essere eseguiti contemporaneamente;
  - Una volta avviato, ogni processo esegue la propria funzione di destinazione in modo indipendente dagli altri.

- **Esecuzione parallela:**
  - Entrambi i processi attendono per durate diverse (`2` e `1` secondi) utilizzando `time.sleep()`;
  - Poiché vengono eseguiti in parallelo, il processo con il ritardo più breve termina per primo, anche se è stato avviato dopo l'altro.

- **Join dei processi:**
  - Il metodo `join()` garantisce che il programma principale attenda la fine di entrambi i processi prima di proseguire;
  - Senza `join()`, il programma principale potrebbe terminare prima che i processi abbiano completato l'esecuzione.

Questo esempio mostra che con il multiprocessing, le attività possono essere eseguite contemporaneamente su più core della CPU, rendendolo ideale per operazioni CPU-bound che traggono vantaggio dall'esecuzione parallela.

Quale affermazione descrive meglio la differenza tra thread e processi in Python?

Acquisizione di competenze pratiche nella gestione dei moduli e delle importazioni in Python per una gestione efficiente del codice. Padronanza delle tecniche avanzate di gestione degli errori per applicazioni più affidabili, automazione delle operazioni sui file con la gestione dei file e apprendimento di strategie di testing robuste con Pytest e Unittest per garantire l'integrità del codice.

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.

Lavorare con i processi

Concetti chiave illustrati