Blog Post

Desenvolvedores BR
4 MIN READ

Multithreading, GIL e paralelismo no Python

ClaudioGodoy's avatar
ClaudioGodoy
Icon for Microsoft rankMicrosoft
Aug 04, 2026

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/zlib em 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:

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 threading e multiprocessing: 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 threading ou asyncio (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.

Updated Aug 04, 2026
Version 2.0
No CommentsBe the first to comment