Summary
This chapter explains how to use multiprocessing to achieve true parallelism by spawning separate processes with isolated memory spaces, demonstrating process creation, starting, joining, and data sharing via queues for interprocess communication.

General domain of usage
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. 



El módulo **`multiprocessing`** de Python permite lograr **paralelismo real** creando procesos independientes, cada uno con su propio intérprete de Python y espacio de memoria. A diferencia de los hilos, que comparten memoria y se ejecutan en el mismo proceso, **los procesos están completamente aislados** entre sí. Este aislamiento evita la limitación del **Global Interpreter Lock (GIL)**, permitiendo que varios núcleos de CPU trabajen en paralelo en tareas intensivas para la CPU. Después de ver el video anterior, se debe comprender que el **paralelismo basado en procesos** es especialmente útil cuando se necesita realizar cálculos pesados o aprovechar varios núcleos para tareas que, de otro modo, estarían limitadas por el GIL. El módulo **`multiprocessing`** proporciona una API familiar similar al módulo **`threading`**, lo que facilita alternar entre hilos y procesos según las necesidades.

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.

Utilizar estas clases y funciones para construir aplicaciones paralelas robustas, gestionar el intercambio de datos y coordinar la ejecución de procesos en 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()


Este ejemplo de código demuestra cómo utilizar el módulo **`multiprocessing`** de Python para ejecutar tareas en paralelo creando procesos independientes. El ejemplo utiliza simples retardos de tiempo e imprime mensajes para mostrar cómo los procesos pueden ejecutarse de manera independiente y simultánea.

#### Conceptos clave ilustrados

- **Creación de procesos:**
  - Se crean nuevos procesos utilizando la clase `multiprocessing.Process`;
  - A cada proceso se le asigna una función objetivo (`print_message`) y los argumentos que se le pasarán a esa función.

- **Inicio de procesos:**
  - El método `start()` inicia cada proceso, permitiendo que se ejecuten concurrentemente;
  - Una vez iniciados, cada proceso ejecuta su función objetivo de forma independiente de los demás.

- **Ejecución en paralelo:**
  - Ambos procesos duermen durante diferentes periodos (`2` y `1` segundos) usando `time.sleep()`;
  - Como se ejecutan en paralelo, el proceso con el retardo más corto termina primero, incluso si fue iniciado después del otro.

- **Unión de procesos:**
  - El método `join()` asegura que el programa principal espere a que ambos procesos finalicen antes de continuar;
  - Sin `join()`, el programa principal podría finalizar antes de que los procesos terminen.

Este ejemplo muestra que con multiprocessing, las tareas pueden ejecutarse al mismo tiempo en varios núcleos de CPU, lo que lo hace ideal para operaciones intensivas en CPU que se benefician de la ejecución paralela.

¿Qué afirmación describe mejor la diferencia entre hilos y procesos en Python?

Un análisis profundo de conceptos avanzados de programación estructural en Python, enfocado en el manejo robusto de archivos, gestión de errores, concurrencia, programación asíncrona y pruebas.

Domina el sistema de excepciones de Python para un manejo de errores y depuración robustos.

Explora técnicas avanzadas para operaciones de archivos y gestión de recursos utilizando gestores de contexto.

Comparación y aplicación de los módulos de multithreading y multiprocessing de Python para la programación concurrente.

Domina la programación asíncrona en Python utilizando la biblioteca asyncio para aplicaciones escalables dependientes de E/S.

Explora cómo escribir, organizar y ejecutar pruebas utilizando los frameworks unittest y pytest de Python.

Trabajando con Procesos

Conceptos clave ilustrados