antonino, Autor em Área de Trampo

GIL em Python

22/05/202622/04/2026 Por antonino

GIL significa Global Interpreter Lock (Trava Global do Interpretador). É um mutex que protege o acesso a objetos internos do Python. Primeiramente, o GIL permite que apenas uma thread execute bytecode por vez. Por exemplo, mesmo com 8 núcleos de CPU, apenas um executa Python puro. Isso limita severamente o paralelismo para código CPU-intensivo. Além disso, o GIL simplifica a gerência de memória do Python. A voz passiva é usada aqui: “objetos são protegidos contra corrupção pelo GIL”. Quando o GIL é um problema? Em tarefas que consomem muita CPU. Por exemplo, cálculos matemáticos, loops pesados ou processamento de imagens. Por outro lado, o GIL não atrapalha operações de I/O. Leitura de arquivos, requisições de rede ou acesso a banco são liberados. Portanto, Python com threads é excelente para I/O-bound. Vamos explorar na prática esses conceitos. Três subtítulos mostram quando o GIL atrapalha ou ajuda.

Gil prejudicando: cpu-bound com threads

Quando o código é intensivo em CPU, threads não ajudam. O GIL força as threads a executarem uma por vez. Portanto, o ganho de performance é zero ou negativo. Por exemplo, calcular números primos em várias threads não acelera. A voz passiva é aplicada: “o tempo total é similar ao sequencial”. Veja um exemplo prático dessa limitação:

import threading
import time

def tarefa_cpu_pesada():
    """Função que consome muita CPU."""
    total = 0
    for i in range(50_000_000):
        total += i * i
    return total

def executar_sequencial():
    """Executa a tarefa várias vezes em sequência."""
    inicio = time.time()
    for _ in range(4):
        tarefa_cpu_pesada()
    return time.time() - inicio

def executar_com_threads():
    """Executa a tarefa em threads paralelas."""
    threads = []
    inicio = time.time()
    for _ in range(4):
        t = threading.Thread(target=tarefa_cpu_pesada)
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    return time.time() - inicio

if __name__ == "__main__":
    print("Executando sequencialmente...")
    tempo_seq = executar_sequencial()
    print(f"Sequencial: {tempo_seq:.2f} segundos")
    
    print("\nExecutando com 4 threads...")
    tempo_thread = executar_com_threads()
    print(f"Com threads: {tempo_thread:.2f} segundos")
    
    print(f"\nAceleração: {tempo_seq / tempo_thread:.2f}x")
    print("(Esperado próximo de 1.0, não 4.0)")

import threading

import time

def tarefa_cpu_pesada():

"""Função que consome muita CPU."""

total = 0

for i in range(50_000_000):

total += i * i

return total

def executar_sequencial():

"""Executa a tarefa várias vezes em sequência."""

inicio = time.time()

for _ in range(4):

tarefa_cpu_pesada()

return time.time() - inicio

def executar_com_threads():

"""Executa a tarefa em threads paralelas."""

threads = []

inicio = time.time()

for _ in range(4):

t = threading.Thread(target=tarefa_cpu_pesada)

threads.append(t)

t.start()

for t in threads:

t.join()

return time.time() - inicio

if __name__ == "__main__":

print("Executando sequencialmente...")

tempo_seq = executar_sequencial()

print(f"Sequencial: {tempo_seq:.2f} segundos")

print("\nExecutando com 4 threads...")

tempo_thread = executar_com_threads()

print(f"Com threads: {tempo_thread:.2f} segundos")

print(f"\nAceleração: {tempo_seq / tempo_thread:.2f}x")

print("(Esperado próximo de 1.0, não 4.0)")

O resultado mostra aceleração próxima de 1.0. Ou seja, threads não trouxeram ganho para CPU. Para esses casos, use multiprocessing ou bibliotecas em C (NumPy).

Gil ajudando: i/o-bound com threads

Para operações de I/O, o GIL é liberado durante a espera. Enquanto uma thread aguarda dados da rede, outra executa. Portanto, threads trazem ganhos enormes para I/O-bound. Por exemplo, baixar 10 arquivos simultaneamente é muito mais rápido. A voz passiva é aplicada: “as operações de I/O são realizadas fora do GIL”. Exemplo demonstrando a eficiência para I/O:

import threading
import time
import requests

def tarefa_io_pesada(url, nome):
    """Simula uma operação de I/O (requisição de rede)."""
    inicio = time.time()
    resposta = requests.get(url)
    tempo = time.time() - inicio
    print(f"[{nome}] {url} -> {resposta.status_code} em {tempo:.2f}s")
    return tempo

def executar_io_sequencial():
    """Executa requisições em sequência."""
    urls = ['https://httpbin.org/delay/1'] * 5
    inicio = time.time()
    for i, url in enumerate(urls):
        tarefa_io_pesada(url, f"Seq-{i}")
    return time.time() - inicio

def executar_io_com_threads():
    """Executa requisições em threads concorrentes."""
    urls = ['https://httpbin.org/delay/1'] * 5
    threads = []
    inicio = time.time()
    
    for i, url in enumerate(urls):
        t = threading.Thread(target=tarefa_io_pesada, args=(url, f"Thread-{i}"))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    return time.time() - inicio

if __name__ == "__main__":
    print("=== Teste com I/O (requisições de 1 segundo cada) ===\n")
    
    tempo_seq = executar_io_sequencial()
    print(f"\nTotal sequencial: {tempo_seq:.2f}s")
    
    tempo_thread = executar_io_com_threads()
    print(f"Total com threads: {tempo_thread:.2f}s")
    
    print(f"\nAceleração: {tempo_seq / tempo_thread:.2f}x")
    print("(Esperado próximo de 5.0 - ganho real!)")

import threading

import time

import requests

def tarefa_io_pesada(url, nome):

"""Simula uma operação de I/O (requisição de rede)."""

inicio = time.time()

resposta = requests.get(url)

tempo = time.time() - inicio

print(f"[{nome}] {url} -> {resposta.status_code} em {tempo:.2f}s")

return tempo

def executar_io_sequencial():

"""Executa requisições em sequência."""

urls = ['https://httpbin.org/delay/1'] * 5

inicio = time.time()

for i, url in enumerate(urls):

tarefa_io_pesada(url, f"Seq-{i}")

return time.time() - inicio

def executar_io_com_threads():

"""Executa requisições em threads concorrentes."""

urls = ['https://httpbin.org/delay/1'] * 5

threads = []

inicio = time.time()

for i, url in enumerate(urls):

t = threading.Thread(target=tarefa_io_pesada, args=(url, f"Thread-{i}"))

threads.append(t)

t.start()

for t in threads:

t.join()

return time.time() - inicio

if __name__ == "__main__":

print("=== Teste com I/O (requisições de 1 segundo cada) ===\n")

tempo_seq = executar_io_sequencial()

print(f"\nTotal sequencial: {tempo_seq:.2f}s")

tempo_thread = executar_io_com_threads()

print(f"Total com threads: {tempo_thread:.2f}s")

print(f"\nAceleração: {tempo_seq / tempo_thread:.2f}x")

print("(Esperado próximo de 5.0 - ganho real!)")

Threads reduzem o tempo total de 5 segundos para cerca de 1 segundo. Isso é o poder da concorrência para operações de I/O. A fórmula do ganho teórico é: \(G = \frac{T_{\text{sequencial}}}{T_{\text{thread}}} \approx N_{\text{tarefas}}\) Quando as tarefas são independentes e bloqueantes.

Alternativas para contornar o gil

Para CPU-bound, use multiprocessing em vez de threading. Cada processo tem seu próprio GIL e memória separada. Assim, você aproveita múltiplos núcleos de verdade. Outra alternativa é usar bibliotecas em C como NumPy. Elas liberam o GIL durante operações pesadas. Para I/O-bound, threading e asyncio são excelentes. A escolha certa depende do seu problema específico. A voz passiva é aplicada: “decisões informadas são tomadas após medição”. Exemplo de multiprocessing para contornar o GIL:

import multiprocessing
import time

def trabalho_cpu_pesado(n):
    """Função CPU-bound que libera o GIL via multiprocessing."""
    total = 0
    for i in range(50_000_000):
        total += i * i
    return total

def com_multiprocessing():
    """Usa múltiplos processos para contornar o GIL."""
    with multiprocessing.Pool(processes=4) as pool:
        resultados = pool.map(trabalho_cpu_pesado, range(4))
    return resultados

def com_threads_falho():
    """Tenta usar threads (falha devido ao GIL)."""
    import threading
    resultados = [0] * 4
    
    def wrapper(idx):
        resultados[idx] = trabalho_cpu_pesado(idx)
    
    threads = []
    for i in range(4):
        t = threading.Thread(target=wrapper, args=(i,))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    return resultados

if __name__ == "__main__":
    print("Multiprocessing (contorna o GIL):")
    inicio = time.time()
    com_multiprocessing()
    print(f"Tempo: {time.time() - inicio:.2f}s")
    
    print("\nThreads (limitado pelo GIL):")
    inicio = time.time()
    com_threads_falho()
    print(f"Tempo: {time.time() - inicio:.2f}s")

import multiprocessing

import time

def trabalho_cpu_pesado(n):

"""Função CPU-bound que libera o GIL via multiprocessing."""

total = 0

for i in range(50_000_000):

total += i * i

return total

def com_multiprocessing():

"""Usa múltiplos processos para contornar o GIL."""

with multiprocessing.Pool(processes=4) as pool:

resultados = pool.map(trabalho_cpu_pesado, range(4))

return resultados

def com_threads_falho():

"""Tenta usar threads (falha devido ao GIL)."""

import threading

resultados = [0] * 4

def wrapper(idx):

resultados[idx] = trabalho_cpu_pesado(idx)

threads = []

for i in range(4):

t = threading.Thread(target=wrapper, args=(i,))

threads.append(t)

t.start()

for t in threads:

t.join()

return resultados

if __name__ == "__main__":

print("Multiprocessing (contorna o GIL):")

inicio = time.time()

com_multiprocessing()

print(f"Tempo: {time.time() - inicio:.2f}s")

print("\nThreads (limitado pelo GIL):")

inicio = time.time()

com_threads_falho()

print(f"Tempo: {time.time() - inicio:.2f}s")

Multiprocessing mostra aceleração real próxima ao número de núcleos. Threads para CPU-bound mostram aceleração próxima de 1.0. Entenda o GIL e escolha a ferramenta certa. Para I/O: threading ou asyncio. Para CPU: multiprocessing, NumPy ou Cython. O GIL não é um monstro, apenas uma característica. Aprenda a conviver com ele e seja feliz em Python.

Multithreading em Python

22/05/202622/04/2026 Por antonino

Multithreading permite múltiplas threads dentro de um único processo. Cada thread executa um fluxo independente de instruções. Primeiramente, threads compartilham a mesma memória do processo. Por exemplo, duas threads podem acessar a mesma variável global. Isso facilita a comunicação entre elas. Além disso, threads são mais leves que processos completos. A voz passiva é usada aqui: “as threads são gerenciadas pelo sistema operacional”. Quando utilizar multithreading em Python? Em operações de I/O. Por exemplo, downloads de rede, leitura de arquivos ou consultas a banco. No entanto, o GIL (Global Interpreter Lock) limita a execução paralela. Portanto, threads não aceleram código com CPU intensivo. Vamos explorar criação, sincronização e boas práticas. Três subtítulos guiarão você pelo mundo do threading. Ao final, você dominará a concorrência em Python.

Criando e gerenciando threads

Python oferece o módulo threading para trabalhar com threads. A classe Thread representa uma thread executável. Para criar uma thread, instancie Thread(target=funcao). Depois, chame start() para iniciar a execução. O método join() espera a thread terminar. Quando usar criação manual? Em scripts com poucas threads controladas. A voz passiva é aplicada: “os argumentos são passados via args“. Exemplo básico de criação de threads:

import threading
import time

def trabalhador(nome, segundos):
    """Função executada por cada thread."""
    print(f"Thread {nome}: iniciando")
    time.sleep(segundos)
    print(f"Thread {nome}: finalizada após {segundos}s")

# Criando threads manualmente
t1 = threading.Thread(target=trabalhador, args=("A", 2))
t2 = threading.Thread(target=trabalhador, args=("B", 1))

# Iniciando as threads
t1.start()
t2.start()

# Aguardando ambas terminarem
t1.join()
t2.join()

print("Todas as threads finalizaram")

# Usando lista de threads
threads = []
for i in range(5):
    t = threading.Thread(target=trabalhador, args=(f"Thread-{i}", i % 3 + 1))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

import threading

import time

def trabalhador(nome, segundos):

"""Função executada por cada thread."""

print(f"Thread {nome}: iniciando")

time.sleep(segundos)

print(f"Thread {nome}: finalizada após {segundos}s")

# Criando threads manualmente

t1 = threading.Thread(target=trabalhador, args=("A", 2))

t2 = threading.Thread(target=trabalhador, args=("B", 1))

# Iniciando as threads

t1.start()

t2.start()

# Aguardando ambas terminarem

t1.join()

t2.join()

print("Todas as threads finalizaram")

# Usando lista de threads

threads = []

for i in range(5):

t = threading.Thread(target=trabalhador, args=(f"Thread-{i}", i % 3 + 1))

threads.append(t)

t.start()

for t in threads:

t.join()

Threads executam concorrentemente, não em paralelo real. O GIL alterna entre elas rapidamente, dando a ilusão de simultaneidade. Para I/O, isso é suficiente e muito eficiente.

Sincronização entre threads

Quando threads compartilham dados, podem ocorrer condições de corrida. Por exemplo, duas threads incrementando a mesma variável simultaneamente. Isso corrompe o resultado final. Para evitar isso, use mecanismos de sincronização. O Lock (mutex) permite que apenas uma thread execute uma seção crítica. Outros mecanismos incluem RLock, Semaphore e Event. Quando usar locks? Sempre que múltiplas threads acessarem dados compartilhados. A voz passiva é usada aqui: “os recursos compartilhados são protegidos por locks”. Exemplo de contador seguro com lock:

import threading
import time

# Sem sincronização (INCORRETO)
contador_sem_lock = 0

def incrementar_sem_lock():
    global contador_sem_lock
    for _ in range(100000):
        contador_sem_lock += 1

# Com sincronização (CORRETO)
contador_com_lock = 0
lock = threading.Lock()

def incrementar_com_lock():
    global contador_com_lock
    for _ in range(100000):
        with lock:  # Entrada na seção crítica
            contador_com_lock += 1
        # Saída automática da seção crítica

# Executando sem lock
threads_sem = []
for _ in range(5):
    t = threading.Thread(target=incrementar_sem_lock)
    threads_sem.append(t)
    t.start()

for t in threads_sem:
    t.join()
print(f"Sem lock: {contador_sem_lock} (esperado: 500000)")

# Executando com lock
threads_com = []
for _ in range(5):
    t = threading.Thread(target=incrementar_com_lock)
    threads_com.append(t)
    t.start()

for t in threads_com:
    t.join()
print(f"Com lock: {contador_com_lock} (esperado: 500000)")

# Exemplo de deadlock (evite!)
lock_a = threading.Lock()
lock_b = threading.Lock()

def tarefa_1():
    with lock_a:
        time.sleep(0.01)
        with lock_b:  # Pode causar deadlock com tarefa_2
            pass

def tarefa_2():
    with lock_b:
        time.sleep(0.01)
        with lock_a:  # Pode causar deadlock com tarefa_1
            pass

import threading

import time

# Sem sincronização (INCORRETO)

contador_sem_lock = 0

def incrementar_sem_lock():

global contador_sem_lock

for _ in range(100000):

contador_sem_lock += 1

# Com sincronização (CORRETO)

contador_com_lock = 0

lock = threading.Lock()

def incrementar_com_lock():

global contador_com_lock

for _ in range(100000):

with lock: # Entrada na seção crítica

contador_com_lock += 1

# Saída automática da seção crítica

# Executando sem lock

threads_sem = []

for _ in range(5):

t = threading.Thread(target=incrementar_sem_lock)

threads_sem.append(t)

t.start()

for t in threads_sem:

t.join()

print(f"Sem lock: {contador_sem_lock} (esperado: 500000)")

# Executando com lock

threads_com = []

for _ in range(5):

t = threading.Thread(target=incrementar_com_lock)

threads_com.append(t)

t.start()

for t in threads_com:

t.join()

print(f"Com lock: {contador_com_lock} (esperado: 500000)")

# Exemplo de deadlock (evite!)

lock_a = threading.Lock()

lock_b = threading.Lock()

def tarefa_1():

with lock_a:

time.sleep(0.01)

with lock_b: # Pode causar deadlock com tarefa_2

pass

def tarefa_2():

with lock_b:

time.sleep(0.01)

with lock_a: # Pode causar deadlock com tarefa_1

pass

O resultado sem lock será imprevisível e geralmente menor que 500000. Com lock, o resultado é sempre correto, porém mais lento. A fórmula do tempo de execução com contenção é: \(T = T_0 + C \times L\) Onde C é o número de aquisições e L é a latência do lock.

Threads vs. outras formas de concorrência

Threads são ótimas para I/O-bound com poucas conexões. Para CPU-bound, prefira multiprocessing (processos separados). Para milhares de conexões simultâneas, asyncio é superior. Quando escolher threading especificamente? Em projetos simples. Também quando você já tem código síncrono e não quer reescrever. Threads são mais fáceis de entender que asyncio. A desvantagem é o GIL e a complexidade de locks. A voz passiva é aplicada: “decisões de arquitetura são baseadas no tipo de tarefa”. Exemplo prático de pool de threads para tarefas I/O:

import threading
from concurrent.futures import ThreadPoolExecutor
import requests
import time

urls = [
    'https://httpbin.org/delay/1',
    'https://httpbin.org/delay/2',
    'https://httpbin.org/delay/0.5',
] * 5  # 15 URLs no total

def baixar(url):
    inicio = time.time()
    resposta = requests.get(url)
    return url, resposta.status_code, time.time() - inicio

# Usando ThreadPoolExecutor (mais elegante)
print("Usando ThreadPoolExecutor:")
with ThreadPoolExecutor(max_workers=5) as executor:
    resultados = executor.map(baixar, urls)
    for url, status, tempo in resultados:
        print(f"{url} -> status {status} em {tempo:.2f}s")

# Alternativa manual com lista de threads
print("\nUsando threads manuais:")
threads = []
resultados_manuais = []

def baixar_e_armazenar(url, idx):
    _, status, tempo = baixar(url)
    resultados_manuais.append((idx, status, tempo))

for i, url in enumerate(urls):
    t = threading.Thread(target=baixar_e_armazenar, args=(url, i))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

import threading

from concurrent.futures import ThreadPoolExecutor

import requests

import time

urls = [

'https://httpbin.org/delay/1',

'https://httpbin.org/delay/2',

'https://httpbin.org/delay/0.5',

] * 5 # 15 URLs no total

def baixar(url):

inicio = time.time()

resposta = requests.get(url)

return url, resposta.status_code, time.time() - inicio

# Usando ThreadPoolExecutor (mais elegante)

print("Usando ThreadPoolExecutor:")

with ThreadPoolExecutor(max_workers=5) as executor:

resultados = executor.map(baixar, urls)

for url, status, tempo in resultados:

print(f"{url} -> status {status} em {tempo:.2f}s")

# Alternativa manual com lista de threads

print("\nUsando threads manuais:")

threads = []

resultados_manuais = []

def baixar_e_armazenar(url, idx):

_, status, tempo = baixar(url)

resultados_manuais.append((idx, status, tempo))

for i, url in enumerate(urls):

t = threading.Thread(target=baixar_e_armazenar, args=(url, i))

threads.append(t)

t.start()

for t in threads:

t.join()

ThreadPoolExecutor simplifica o gerenciamento de threads. Ele reutiliza threads para evitar custo de criação. Use max_workers entre 5 e 10 para tarefas de rede. Nunca crie mais de 100 threads simultâneas. O sistema operacional pode ficar sobrecarregado. Threads são ferramentas poderosas quando usadas corretamente. Domine os locks e evite deadlocks. Sua aplicação ficará mais rápida e responsiva. Comece com pequenos exemplos e escale gradualmente.