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. 



O módulo **`multiprocessing`** do Python permite alcançar **paralelismo real** ao criar processos separados, cada um com seu próprio interpretador Python e espaço de memória. Diferente das threads, que compartilham memória e executam no mesmo processo, **os processos são completamente isolados** uns dos outros. Esse isolamento evita a limitação do **Global Interpreter Lock (GIL)**, permitindo que múltiplos núcleos de CPU trabalhem em paralelo em tarefas que exigem uso intensivo de CPU. Após assistir ao vídeo acima, deve ficar claro que o **paralelismo baseado em processos** é especialmente útil quando é necessário realizar cálculos pesados ou aproveitar múltiplos núcleos para tarefas que, de outra forma, seriam limitadas pelo GIL. O módulo **`multiprocessing`** oferece uma API familiar, semelhante ao módulo **`threading`**, facilitando a alternância entre threading e processing conforme a necessidade.

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.

Utilização dessas classes e funções para construir aplicações paralelas robustas, gerenciar compartilhamento de dados e coordenar a execução de processos em 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 exemplo de código demonstra como usar o módulo **`multiprocessing`** do Python para executar tarefas em paralelo criando processos separados. O exemplo utiliza atrasos simples de tempo e imprime mensagens para mostrar como os processos podem ser executados de forma independente e simultânea.

#### Conceitos-chave ilustrados

- **Criação de Processos:**
  - Novos processos são criados usando a classe `multiprocessing.Process`;
  - Cada processo recebe uma função alvo (`print_message`) e argumentos para passar para essa função.

- **Inicialização de Processos:**
  - O método `start()` inicia cada processo, permitindo que eles sejam executados concorrentemente;
  - Uma vez iniciados, cada processo executa sua função alvo independentemente dos outros.

- **Execução Paralela:**
  - Ambos os processos dormem por durações diferentes (`2` e `1` segundos) usando `time.sleep()`;
  - Como são executados em paralelo, o processo com menor atraso termina primeiro, mesmo tendo sido iniciado depois do outro.

- **Junção de Processos:**
  - O método `join()` garante que o programa principal aguarde ambos os processos terminarem antes de prosseguir;
  - Sem o `join()`, o programa principal poderia encerrar antes dos processos concluírem.

Este exemplo mostra que, com multiprocessing, tarefas podem ser executadas ao mesmo tempo em múltiplos núcleos de CPU, tornando-o ideal para operações que exigem processamento intenso e se beneficiam da execução paralela.

Qual afirmação melhor descreve a diferença entre threads e processos em Python?

Uma análise aprofundada de conceitos avançados de programação estrutural em Python, com foco em manipulação robusta de arquivos, gerenciamento de erros, concorrência, programação assíncrona e testes.

Domine o sistema de exceções do Python para tratamento de erros robusto e depuração.

Explore técnicas avançadas para operações de arquivos e gerenciamento de recursos utilizando gerenciadores de contexto.

Comparação e aplicação dos módulos de multithreading e multiprocessing do Python para programação concorrente.

Domine a programação assíncrona em Python utilizando a biblioteca asyncio para aplicações escaláveis orientadas a I/O.

Explore como escrever, organizar e executar testes utilizando os frameworks unittest e pytest do Python.

Trabalhando com Processos

Conceitos-chave ilustrados