Processamento paralelo é um tema complexo e controverso na linguagem Python, podendo variar de acordo com a implementação do interpretador. Neste artigo vou explorar conceitos de processamento paralelo e multithreading em Python, mostrando por que "usar várias threads" nem sempre significa "rodar mais rápido".
Concorrência vs. paralelismo
Os dois conceitos são parecidos, mas não são a mesma coisa:
- Concorrência: lidar com várias tarefas ao mesmo tempo, alternando entre elas. As tarefas progridem de forma intercalada, mas não necessariamente executam no mesmo instante. É ideal para trabalho I/O-bound (rede, disco, banco de dados), onde o programa passa a maior parte do tempo esperando.
- Paralelismo: executar várias tarefas literalmente ao mesmo tempo, em múltiplos núcleos de CPU. É o que acelera trabalho CPU-bound (cálculo pesado, compressão, hashing).
Resumindo: todo paralelismo é concorrência, mas nem toda concorrência é paralelismo.
Para concorrência de I/O sem threads, o Python oferece o asyncio, baseado em uma única thread com um event loop e a sintaxe async/await. Como ele não cria threads nem processos, é leve e eficiente para milhares de conexões simultâneas — mas não oferece paralelismo de CPU.
Threads e o GIL: por que multithreading não paraleliza CPU
O módulo threading permite criar threads reais do sistema operacional, mas o CPython usa o GIL (Global Interpreter Lock): uma trava global que garante que apenas uma thread execute bytecode Python por vez.
Por que ele existe? O GIL simplifica o interpretador e torna o modelo de objetos (incluindo tipos como dict) implicitamente seguro contra acesso concorrente, além de facilitar a integração com bibliotecas C. O preço é abrir mão de boa parte do paralelismo em máquinas multi-core.
Na prática:
- Tarefas I/O-bound se beneficiam de threads, pois o GIL é liberado durante operações de I/O (e por extensões como
hashlib/zlibem trechos pesados). - Tarefas CPU-bound não escalam com threads: o GIL serializa a execução, e usar mais threads não deixa o programa mais rápido — às vezes até o deixa mais lento pelo overhead de troca de contexto.
Desde o Python 3.13 existe um build experimental free-threaded (compilado com
--disable-gil, descrito na PEP 703) que permite desligar o GIL. Porém isso exige um interpretador compilado especificamente para isso (python3.14t); as compilações padrão não permitem desabilitá-lo.
O GIL não dispensa sincronização
Mesmo com o GIL, ainda precisamos nos preocupar com sincronização. O GIL garante que uma instrução de bytecode não seja interrompida no meio, mas operações de alto nível (como contador += 1) envolvem várias instruções de bytecode e podem sofrer race conditions se uma thread for interrompida no meio delas.
Por isso o módulo threading oferece primitivos de sincronização — todos usáveis com with para liberação automática:
Lock/RLock— exclusão mútua.Semaphore— limita o número de acessos simultâneos.Condition/Event— coordenação entre threads.
Multiprocessing: paralelismo real com processos
A saída para aplicações CPU-bound é o módulo multiprocessing (ou o ProcessPoolExecutor do concurrent.futures). Em vez de threads, ele cria processos separados, e cada processo tem seu próprio interpretador e seu próprio GIL, permitindo paralelismo real em múltiplos núcleos.
O custo intrínseco é que criar um novo processo cria também um interpretador Python inteiro, o que é pesado em memória e no tempo de inicialização. Além disso, processos não compartilham memória: os dados precisam ser serializados (via pickle) e trocados por mecanismos de comunicação entre processos como Queue e Pipe, ou por memória compartilhada. Isso torna a sincronização mais complexa e adiciona overhead de comunicação.
Benchmark: medindo o impacto do GIL
Para comprovar o conceito, um pequeno script calcula muitos hashes SHA-256 encadeados (uma tarefa puramente CPU-bound) e distribui esse trabalho de três formas, usando concurrent.futures:
- Sequencial — executa tudo em uma única thread, servindo de baseline.
ThreadPoolExecutor— divide o trabalho entre várias threads.ProcessPoolExecutor— divide o trabalho entre vários processos.
Cada abordagem é medida em tempo de execução e memória consumida. Rodando no Python 3.14.6 (16 núcleos), o resultado foi:
Abordagem Tempo Speedup Memória
------------------------------------------------------------
Sequencial 0.79s 1.00x 0.0 MB
ThreadPoolExecutor 0.80s 0.99x 0.2 MB
ProcessPoolExecutor 0.31s 2.56x 148.6 MB
Interpretando os números:
- As threads não aceleraram a tarefa (speedup ~1.0x, praticamente igual ao sequencial). O GIL serializou a execução do bytecode: mesmo com várias threads, apenas uma roda por vez, então não há ganho de paralelismo para trabalho de CPU.
- Os processos foram ~2.5x mais rápidos. Como cada processo tem seu próprio interpretador e seu próprio GIL, o trabalho realmente rodou em paralelo em vários núcleos.
- Esse paralelismo cobra um custo de memória: os 8 processos consumiram ~148 MB (~18,6 MB por interpretador novo), contra apenas ~0,2 MB das threads, que compartilham o mesmo processo. É o trade-off central entre
threadingemultiprocessing: velocidade real de CPU ao preço de duplicar o interpretador em memória.
Conclusão: I/O-bound ou CPU-bound?
O GIL é a razão pela qual multithreading no CPython não entrega paralelismo de CPU. A regra prática é:
- I/O-bound → use
threadingouasyncio(o GIL é liberado durante a espera). - CPU-bound → use
multiprocessing, aceitando o custo de memória e de comunicação entre processos. - No futuro, o build free-threaded (PEP 703) promete paralelismo real com threads e sem o custo de vários interpretadores — mas ainda depende de um interpretador compilado sem o GIL.
Escolher a ferramenta certa depende, antes de tudo, de entender se o gargalo é de I/O ou de CPU.