Python Academy · Aula

Threads e o GIL

Entenda os limites das threads do Python

Threads e o GIL é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

O que é um encadeamento

Um encadeamento é um fluxo separado de execução dentro de um processo. O módulo threading do Python permite executar funções concorrentemente em um único programa.

import threading

def worker():
    print('hello from thread')

t = threading.Thread(target=worker)
t.start()
t.join()
print('main done')

Iniciando vários encadeamentos

Você pode iniciar vários encadeamentos. Cada um executa sua função-alvo. join() faz o encadeamento principal esperar até que um encadeamento termine.

import threading

def task(name):
    print('task', name)

threads = [threading.Thread(target=task, args=(i,)) for i in range(3)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print('all finished')

O bloqueio global do interpretador

O CPython tem um bloqueio global do interpretador (GIL): apenas um encadeamento executa bytecode Python por vez. Isso significa que encadeamentos não oferecem um ganho real de velocidade em paralelo para trabalhos puramente em Python limitados pela CPU.

import sys
print('Running on:', sys.implementation.name)
print('Only one thread runs Python bytecode at a time due to the GIL')

Onde os encadeamentos ainda ajudam

Encadeamentos são excelentes para trabalhos limitados por E/S: solicitações de rede, leituras de disco e esperas. Enquanto um encadeamento espera, o GIL é liberado e outro pode executar.

import threading, time

def fake_io(name):
    time.sleep(0.1)
    print('done', name)

start = time.perf_counter()
ts = [threading.Thread(target=fake_io, args=(i,)) for i in range(3)]
for t in ts: t.start()
for t in ts: t.join()
print('elapsed about 0.1s, not 0.3s')

Trabalhos limitados pela CPU não aceleram

Para cálculos pesados, adicionar encadeamentos não os tornará mais rápidos, porque o GIL os serializa. Para trabalhos limitados pela CPU, use multiprocessing.

import threading

def burn():
    total = 0
    for i in range(1000000):
        total += i
    return total

t = threading.Thread(target=burn)
t.start()
t.join()
print('CPU-bound: threads share one core under the GIL')

Encadeamentos de segundo plano

Um encadeamento de segundo plano é encerrado automaticamente quando o programa principal termina. Use-o para tarefas auxiliares em segundo plano que não precisam ser aguardadas.

import threading, time

def background():
    time.sleep(0.05)
    print('background tick')

t = threading.Thread(target=background, daemon=True)
t.start()
t.join()
print('main exits')

Nomeando e identificando encadeamentos

Cada encadeamento tem um nome e um identificador. threading.current_thread() retorna o objeto do encadeamento em execução, o que é útil para registros.

import threading

def show():
    t = threading.current_thread()
    print('running in', t.name)

t = threading.Thread(target=show, name='Worker-1')
t.start()
t.join()
print('main thread:', threading.current_thread().name)

Criando uma subclasse de Thread

Em vez de passar um destino, você pode criar uma subclasse de Thread e substituir run(). Isso é útil quando um encadeamento precisa ter seu próprio estado.

import threading

class Greeter(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.who = name
    def run(self):
        print('hi', self.who)

g = Greeter('Sam')
g.start()
g.join()

Retornando resultados de encadeamentos

O valor retornado por uma função-alvo é descartado. Para coletar resultados, escreva-os em uma estrutura compartilhada (mais adiante, você verá ferramentas mais seguras, como filas).

import threading

results = {}

def compute(key):
    results[key] = key * key

ts = [threading.Thread(target=compute, args=(i,)) for i in range(4)]
for t in ts: t.start()
for t in ts: t.join()
print(results)

Contando encadeamentos ativos

threading.active_count() informa quantos encadeamentos estão vivos no momento, incluindo o encadeamento principal.

import threading, time

def wait():
    time.sleep(0.05)

ts = [threading.Thread(target=wait) for _ in range(2)]
for t in ts: t.start()
print('active now:', threading.active_count())
for t in ts: t.join()
print('active after join:', threading.active_count())

Escolhendo entre encadeamentos e processos

Regra geral: use encadeamentos para concorrência limitada por E/S e processos para paralelismo limitado pela CPU. O GIL é o motivo.

tasks = {'download files': 'threads', 'crunch numbers': 'processes', 'call APIs': 'threads'}
for task, choice in tasks.items():
    print(task, '->', choice)

Verificação rápida

Teste sua compreensão de encadeamentos e do GIL.

Recapitulação

Você aprendeu sobre encadeamentos e o GIL:

Encadeamentos executam concorrentemente dentro de um processo por meio de threading.Thread.
O GIL serializa a execução do bytecode Python.
Encadeamentos ajudam em trabalhos limitados por E/S; processos ajudam em trabalhos limitados pela CPU.
Use start(), join(), encadeamentos de segundo plano e criação de subclasses.

Em seguida: gerenciando encadeamentos de forma organizada com ThreadPoolExecutor.

Perguntas Frequentes

A aula “Threads e o GIL” é grátis?

Sim — o texto completo de “Threads e o GIL” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Threads e o GIL”?

Entenda os limites das threads do Python Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Threads e o GIL”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy