Paralelismo (Parallelism)

Definição

Paralelismo (Parallelism) é a capacidade de executar múltiplas tarefas ao mesmo tempo, aproveitando múltiplos núcleos ou processadores físicos.
Enquanto a concorrência alterna entre tarefas, o paralelismo executa de fato várias tarefas simultaneamente, aumentando o desempenho em tarefas intensivas.

Paralelismo é uma estratégia comum em sistemas modernos para acelerar algoritmos pesados, distribuir carga de trabalho e explorar o máximo do hardware disponível.

Objetivos do Paralelismo

Aumentar a performance geral utilizando múltiplos núcleos de CPU.
Reduzir o tempo de execução de tarefas que podem ser divididas e processadas em paralelo.
Melhorar a eficiência em aplicações de alto custo computacional, como simulações científicas, mineração de dados, renderização gráfica e machine learning.
Distribuir tarefas independentes para execução real simultânea.

Exemplo prático

Neste exemplo, usamos o módulo multiprocessing para executar duas funções em paralelo — cada uma em um processo separado.

from multiprocessing import Process
import time

def tarefa(nome, tempo):
    for i in range(3):
        print(f'{nome} - passo {i}')
        time.sleep(tempo)

if __name__ == "__main__":
    p1 = Process(target=tarefa, args=("Processo A", 1))
    p2 = Process(target=tarefa, args=("Processo B", 1))

    # Inicia os dois processos simultaneamente
    p1.start()
    p2.start()

    # Aguarda os dois processos terminarem antes de continuar
    p1.join()
    p2.join()

Saída esperada

Processo A - passo 0
Processo B - passo 0
Processo A - passo 1
Processo B - passo 1
Processo A - passo 2
Processo B - passo 2

Observe que os dois processos executam seus passos ao mesmo tempo, reduzindo o tempo total de execução.

Se cada tarefa demora 3 segundos, o tempo total será cerca de 3 segundos, e não 6, pois os processos rodam em paralelo.

O ciclo do paralelismo

[Programa principal]
├── Processo A: tarefa 1 (núcleo 1)
└── Processo B: tarefa 2 (núcleo 2)

Cada processo roda em um núcleo diferente (se disponível).
A comunicação entre processos exige mecanismos como filas ou pipes.
Ideal para tarefas que consomem CPU e são independentes entre si.

Em linguagens como Python, o paralelismo com múltiplas threads é limitado pelo GIL (Global Interpreter Lock).
Por isso, usamos o módulo multiprocessing, que cria processos reais, cada um com seu próprio interpretador Python e espaço de memória separado.