Ciências da computação dia 219

Durante nossas aulas de sistemas operacionais, chegamos a um dos tópicos mais importantes da computação moderna: threads e concorrência. Este conceito está presente em praticamente todo software atual, desde servidores web que atendem milhares de requisições simultâneas até aplicativos mobile que precisam manter a interface responsiva enquanto processam dados em segundo plano. Entender como threads funcionam e como gerenciar a concorrência é essencial para qualquer profissional da computação.

O que são Threads?

Uma thread, também chamada de linha de execução, é a menor unidade de processamento que pode ser escalonada de forma independente pelo sistema operacional. Diferente de um processo tradicional, que possui seu próprio espaço de endereçamento isolado, threads pertencentes a um mesmo processo compartilham o mesmo espaço de memória — incluindo código executável, dados do heap, descritores de arquivo e outras estruturas do sistema.

Cada thread mantém seu próprio contexto de execução:

• Program Counter (PC): indica qual instrução está sendo executada no momento
• Pilha de execução (stack): contém variáveis locais, parâmetros de função e endereços de retorno
• Conjunto de registradores da CPU
• Estado de execução (pronto, executando, bloqueado, etc.)

Essa estrutura permite que múltiplas threads dentro de um mesmo processo executem concorrentemente, compartilhando dados de forma eficiente sem a necessidade de mecanismos complexos de comunicação entre processos (IPC). No entanto, esse compartilhamento também introduz desafios significativos de sincronização que precisam ser cuidadosamente gerenciados.

Processos vs Threads

Para entender melhor as vantagens das threads, vamos compará-las com processos tradicionais:

A principal vantagem das threads sobre processos é a eficiência. Criar uma thread é muito mais rápido que criar um processo, e a troca de contexto entre threads de um mesmo processo é menos custosa, pois não envolve alteração do espaço de endereçamento da memória.

Modelos de Thread

Existem três modelos principais de implementação de threads em sistemas operacionais:

Modelo N:1 (Threads de Usuário)

Neste modelo, múltiplas threads de usuário são mapeadas para uma única thread de kernel. O gerenciamento é feito inteiramente por uma biblioteca no espaço do usuário, sem envolvimento do kernel. Vantagens: criação e troca de contexto extremamente rápidas. Desvantagem: se uma thread faz uma chamada de sistema bloqueante (como leitura de arquivo), todo o processo bloqueia, impedindo as outras threads de progredir.

Modelo 1:1 (Threads de Kernel)

Cada thread de usuário é mapeada diretamente para uma thread de kernel. O sistema operacional gerencia o escalonamento e pode distribuir as threads entre múltiplos processadores. Vantagens: aproveitamento real de múltiplos núcleos, bloqueio de uma thread não afeta as outras. Desvantagens: criação mais custosa, maior overhead de sistema para gerenciamento.

Modelo N:M (Híbrido)

Combina os dois modelos anteriores, com múltiplas threads de usuário multiplexadas sobre múltiplas threads de kernel. Busca o melhor dos dois mundos: criação rápida de threads de usuário com paralelismo real de threads de kernel. É o modelo mais flexível, porém mais complexo de implementar.

Concorrência vs Paralelismo

É fundamental distinguir dois conceitos que frequentemente são confundidos:

• Concorrência: é a capacidade de lidar com múltiplas tarefas ao mesmo tempo, alternando a execução entre elas em intervalos de tempo. Mesmo em um sistema com apenas um núcleo de processamento, podemos ter concorrência através do escalonamento por compartilhamento de tempo (time slicing). O objetivo da concorrência é melhorar a estrutura do programa e a responsividade.
• Paralelismo: é a execução simultânea de múltiplas tarefas em múltiplos núcleos ou processadores. Requer hardware com capacidade de processamento paralelo. O objetivo do paralelismo é melhorar o desempenho computacional.

Um sistema pode ser concorrente sem ser paralelo, mas todo sistema paralelo é necessariamente concorrente. Em sistemas multicore modernos, podemos ter ambos: concorrência para gerenciar múltiplas tarefas e paralelismo para executá-las simultaneamente.

Problemas Clássicos de Sincronização

Quando múltiplas threads acessam e manipulam dados compartilhados simultaneamente, surgem problemas clássicos de sincronização:

Race Condition

Ocorre quando o resultado da execução depende da ordem não determinística de acesso aos dados compartilhados. Exemplo clássico: duas threads incrementando um contador global sem proteção — o valor final pode ser menor que o esperado porque as operações de leitura e escrita se intercalam.

Deadlock

Situação em que duas ou mais threads ficam bloqueadas permanentemente, cada uma esperando por um recurso que está retido pela outra. As quatro condições necessárias para um deadlock são: exclusão mútua, posse e espera, não preempção e espera circular.

Starvation

Ocorre quando uma thread nunca consegue acesso a um recurso porque outras threads sempre o tomam antes. O sistema continua progredindo, mas a thread prejudicada nunca avança.

Problema do Produtor-Consumidor

Threads produtoras inserem dados em um buffer compartilhado e threads consumidoras retiram dados. É necessário coordenar o acesso para evitar que o produtor insira em buffer cheio ou o consumidor retire de buffer vazio.

Exemplo Prático em Python

Vamos implementar o problema do produtor-consumidor em Python utilizando threads, semáforos e mutex:

import threading
import time
import random

buffer = []
buffer_max = 5
empty = threading.Semaphore(buffer_max)
full = threading.Semaphore(0)
mutex = threading.Lock()

def produtor():
    for i in range(10):
        item = random.randint(1, 100)
        empty.acquire()
        with mutex:
            buffer.append(item)
            print(f"Produziu: {item} | Buffer: {buffer}")
        full.release()
        time.sleep(random.random())

def consumidor():
    for i in range(10):
        full.acquire()
        with mutex:
            item = buffer.pop(0)
            print(f"Consumiu: {item} | Buffer: {buffer}")
        empty.release()
        time.sleep(random.random())

t1 = threading.Thread(target=produtor)
t2 = threading.Thread(target=consumidor)
t1.start()
t2.start()
t1.join()
t2.join()
print("Concluído!")

Este exemplo usa semáforos para controlar o buffer e um mutex para proteger o acesso à lista compartilhada. Os semáforos empty e full coordenam a produção e o consumo, enquanto o mutex garante que apenas uma thread por vez manipule a lista.

Mecanismos de Sincronização

Para resolver os problemas de concorrência, os sistemas operacionais oferecem diversos mecanismos de sincronização:

• Mutex (Mutual Exclusion): variável de exclusão mútua que permite que apenas uma thread por vez acesse uma região crítica. Opera com as funções lock() e unlock().
• Semáforo: contador que controla o acesso a um ou mais recursos. Inventado por Edsger Dijkstra, suporta duas operações atômicas: wait() (decrementa o contador, bloqueando se zero) e signal() (incrementa e acorda threads bloqueadas). Semáforos binários funcionam como mutexes, enquanto semáforos contadores controlam múltiplas instâncias de um recurso.
• Variável de Condição: permite que threads esperem por uma condição específica dentro de uma região crítica, liberando temporariamente o mutex enquanto aguardam.
• Barreira: ponto de sincronização onde múltiplas threads devem esperar até que todas cheguem antes de continuar a execução.

A escolha do mecanismo adequado depende do problema a ser resolvido e das características de desempenho desejadas.

Conclusão

Threads são fundamentais para construir sistemas eficientes e responsivos. Elas permitem que aplicações aproveitem melhor os recursos do hardware e ofereçam uma experiência mais fluida para o usuário. No entanto, a programação concorrente exige cuidado e disciplina para evitar problemas como race conditions e deadlocks. O uso correto dos mecanismos de sincronização — mutexes, semáforos e variáveis de condição — é essencial para garantir a corretude e a eficiência de programas multithread.

Nos próximos dias, vamos explorar mais a fundo algoritmos de escalonamento e técnicas avançadas de sincronização. Enquanto isso, revise os conceitos vistos hoje e tente implementar os exemplos para consolidar o aprendizado.

Veja mais artigos sobre sistemas operacionais e outros tópicos na página de Posts ou explore por tags na página de Tags.

Perguntas Frequentes

O que é o GIL em Python e como afeta threads?

O Global Interpreter Lock (GIL) é um mutex no CPython que protege o acesso aos objetos Python, garantindo que apenas uma thread execute bytecode por vez. Isso significa que threads em Python não oferecem paralelismo real para tarefas CPU-bound, mas ainda são úteis para operações I/O-bound, onde a thread fica bloqueada aguardando I/O e libera o GIL.

Threads são mais rápidas que processos?

A criação e a troca de contexto de threads são mais rápidas que as de processos, pois threads compartilham o espaço de endereçamento e não necessitam de operações complexas de gerenciamento de memória. No entanto, a escolha entre threads e processos depende do caso de uso: threads são melhores para comunicação intensiva, enquanto processos oferecem maior isolamento e segurança.

Como evitar deadlocks em programas multithread?

Para evitar deadlocks, podemos seguir algumas práticas: (1) estabelecer uma ordem global de aquisição de locks, (2) usar timeouts ao tentar adquirir locks, (3) evitar locks aninhados sempre que possível, (4) usar algoritmos de detecção e recuperação de deadlocks implementados pelo sistema operacional.