Threads
Uma thread é uma linha de execução dentro de um processo.
Até agora, quando falávamos de processos, o modelo era:
Com threads, um processo pode ter várias linhas de execução ao mesmo tempo:
Processo
├── código compartilhado
├── heap compartilhado
├── variáveis globais compartilhadas
├── file descriptors compartilhados
├── thread 1
│ └── stack própria
├── thread 2
│ └── stack própria
└── thread 3
└── stack própria
Processos têm memória separada. Threads do mesmo processo compartilham a mesma memória.
Processo e thread
Processo
Um processo tem seu próprio espaço de memória.
Se o processo A alterar uma variável global, o processo B não verá a mudança. Por isso, para que os processos compartilhem dados, precisamos de IPC:
- Pipe.
- FIFO.
- Socket.
- Fila de mensagens (message queue).
- Memória compartilhada (shared memory).
Thread
Threads vivem dentro do mesmo processo.
Elas compartilham:
- Heap.
- Variáveis globais.
- Arquivos abertos.
- Sockets.
- Memória do processo.
Entretanto, cada thread tem seus próprios recursos:
- Pilha.
- Registradores.
- Fluxo de execução.
Por que as threads existem?
As threads permitem realizar várias atividades dentro do mesmo processo. Exemplos:
- Um servidor que atende vários clientes.
- Um programa que baixa um arquivo enquanto atualiza a interface.
- Um worker que processa uma tarefa em paralelo.
- Uma thread que lê dados enquanto outra os processa.
Em vez de criar vários processos separados, criamos várias threads dentro do mesmo processo.
Primeiro exemplo com pthread_create
Em C, no Linux, normalmente usamos a biblioteca POSIX Threads, conhecida como Pthreads.
Função principal:
Exemplo:
#include <stdio.h>
#include <pthread.h>
void *minha_thread(void *arg) {
printf("Olá, eu sou uma thread.\n");
return NULL;
}
int main(void) {
pthread_t t;
if (pthread_create(&t, NULL, minha_thread, NULL) != 0) {
perror("pthread_create");
return 1;
}
pthread_join(t, NULL);
printf("Thread terminou\n");
return 0;
}
O que aconteceu
pthread_t t;: criamos uma variável que identifica a thread.pthread_create(&t, NULL, minha_thread, NULL);: pedimos para o sistema criar uma nova thread que começa executando a funçãominha_thread().pthread_join(t, NULL): a thread principal do processo espera que a outra thread termine.
Sem pthread_join(), a função main() poderia terminar antes que a thread fosse executada.
A função da thread
A função usada por pthread_create() precisa ter este formato:
Ela recebe um void * e retorna um void *, pois assim podemos passar qualquer tipo de dado para a thread.
Passando argumentos para a thread
#include <stdio.h>
#include <pthread.h>
void *imprimir_numero(void *arg) {
int *numero = (int *) arg;
printf("Número recebido = %d\n", *numero);
return NULL;
}
int main(void) {
pthread_t t;
int valor = 42;
if (pthread_create(&t, NULL, imprimir_numero, &valor) != 0) {
perror("pthread_create");
return 1;
}
pthread_join(t, NULL);
return 0;
}
Threads compartilham variáveis globais
Exemplo:
#include <stdio.h>
#include <pthread.h>
int contador = 0;
void *incrementar(void *arg) {
contador++;
return NULL;
}
int main(void) {
pthread_t t1, t2;
pthread_create(&t1, NULL, incrementar, NULL);
pthread_create(&t2, NULL, incrementar, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf("Contador = %d\n", contador);
return 0;
}
O problema: race condition
Uma condição de corrida (race condition) ocorre quando duas ou mais threads acessam dados compartilhados concorrentemente, pelo menos uma delas realiza uma escrita e não há a sincronização necessária. Dessa forma, o resultado final pode ser incoerente, como no exemplo de várias threads alterando um contador.
#include <stdio.h>
#include <pthread.h>
#define N_THREADS 4
#define N_INC 1000000
int contador = 0;
void *incrementar(void *arg) {
for (int i = 0; i < N_INC; i++) {
contador++;
}
return NULL;
}
int main(void) {
pthread_t threads[N_THREADS];
for (int i = 0; i < N_THREADS; i++) {
pthread_create(&threads[i], NULL, incrementar, NULL);
}
for (int i = 0; i < N_THREADS; i++) {
pthread_join(threads[i], NULL);
}
printf("Esperado: %d\n", N_THREADS * N_INC);
printf("Obtido: %d\n", contador);
return 0;
}
Existem algumas formas de resolver esse problema, detalhadas a seguir.
Mutex
Mutex significa exclusão mútua (mutual exclusion), ou seja, somente uma thread pode entrar na região crítica por vez.
Uma região crítica é um trecho que acessa dados compartilhados. Por exemplo, contador++ precisa ser protegido.
Corrigindo com pthread_mutex_t:
#include <stdio.h>
#include <pthread.h>
#define N_THREADS 4
#define N_INC 1000000
int contador = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *incrementar(void *arg) {
for (int i = 0; i < N_INC; i++) {
pthread_mutex_lock(&mutex);
contador++;
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main(void) {
pthread_t threads[N_THREADS];
for (int i = 0; i < N_THREADS; i++) {
pthread_create(&threads[i], NULL, incrementar, NULL);
}
for (int i = 0; i < N_THREADS; i++) {
pthread_join(threads[i], NULL);
}
printf("Esperado: %d\n", N_THREADS * N_INC);
printf("Obtido: %d\n", contador);
pthread_mutex_destroy(&mutex);
return 0;
}
Como o mutex funciona
Quando uma thread faz: pthread_mutex_lock(&mutex);:
- Ela tenta pegar o mutex.
- Se ninguém estiver usando o mutex, ela entrará.
- Se outra thread já estiver na região crítica, ela esperará.
- Ao terminar, executará
pthread_mutex_unlock(&mutex), liberando o mutex para outra thread.
Visualmente:
Thread A pega mutex
Thread A altera contador
Thread A solta mutex
Thread B pega mutex
Thread B altera contador
Thread B solta mutex
Threads e heap
Como as threads pertencem ao mesmo processo, elas compartilham o heap. Exemplo:
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *thread_func(void *arg) {
int *p = (int *) arg;
*p = 99;
return NULL;
}
int main(void) {
pthread_t t;
int *valor = malloc(sizeof(int));
if (valor == NULL) {
perror("malloc");
return 1;
}
*valor = 10;
pthread_create(&t, NULL, thread_func, valor);
pthread_join(t, NULL);
printf("Valor = %d\n", *valor);
free(valor);
return 0;
}
A thread altera a memória alocada no heap, e a função main() vê a mudança. Isso funciona porque ambas fazem parte do mesmo processo.
Threads e pilha
Cada thread tem sua própria pilha. Exemplo:
void *funcao(void *arg) {
int local = 10;
printf("Endereço local: %p\n", (void *)&local);
return NULL;
}
Se criarmos várias threads, cada uma terá sua própria variável local.
Variáveis locais comuns não são compartilhadas entre threads, porque ficam na pilha de cada uma.
Erro comum: retornar ponteiro para variável local
Errado:
x está na pilha da thread. Quando a função termina, x deixa de existir.
O correto é usar o heap:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
void *funcao(void *arg) {
int *x = malloc(sizeof(int));
if (x == NULL) {
return NULL;
}
*x = 10;
return x;
}
int main(void) {
pthread_t t;
pthread_create(&t, NULL, funcao, NULL);
void *retorno;
pthread_join(t, &retorno);
int *valor = (int *)retorno;
if (valor != NULL) {
printf("Valor retornado = %d\n", *valor);
free(valor);
}
return 0;
}
pthread_join()
pthread_join() espera que a thread termine. Esse comportamento é conceitualmente parecido com o de wait() para processos. As diferenças são:
wait(): espera um processo filho.pthread_join(): espera uma thread.
Se quisermos pegar o retorno da thread:
pthread_detach()
Às vezes, não queremos esperar uma thread com pthread_join(); nesse caso, podemos destacá-la:
Uma thread detached libera seus recursos automaticamente quando termina. Depois disso, não podemos chamar pthread_join() para ela.
Regra prática:
- Quer esperar o resultado? Use
pthread_join(). - Não quer esperar nem precisa do retorno? Use
pthread_detach().
Threads e descritores de arquivo
As threads compartilham descritores de arquivo. Se uma thread abrir um arquivo:
outra thread do mesmo processo poderá usar o mesmo fd, desde que tenha acesso à variável ou receba o valor. Isso vale para:
- Arquivos.
- Pipes.
- Sockets.
- FIFOs.
Esse compartilhamento é útil, mas também pode gerar problemas se não protegermos o acesso com um mutex.
Threads são paralelismo ou concorrência?
Uma thread permite concorrência.
- Concorrência: capacidade do sistema de gerenciar múltiplas tarefas, alternando entre elas. Em um único núcleo, elas progridem de forma intercalada.
- Paralelismo: execução simultânea de duas ou mais tarefas, o que exige múltiplos núcleos de processamento.
Se uma máquina tiver vários núcleos de CPU, as threads poderão ser executadas em paralelo. Mesmo em um único núcleo, o sistema operacional poderá alternar rapidamente entre elas.
O escalonador controla as threads
O kernel agenda as threads para execução. O escalonador (scheduler) escolhe os processos e as threads aptos a executar.
Com threads POSIX no Linux, cada thread é tratada pelo kernel como uma unidade agendável. Então a ordem de execução não é garantida.
Isso significa que não podemos pressupor que uma thread A será executada antes de uma thread B. Para garantir essa ordem, precisamos usar sincronização.
Exemplo útil: servidor com uma thread por cliente
Com sockets TCP, uma arquitetura comum é:
- O servidor aceita um cliente.
- Cria uma thread para atender esse cliente.
- Volta para
accept().
Modelo:
main thread
├── accept()
├── accept()
└── accept()
worker threads
├── cliente 1
├── cliente 2
└── cliente 3
Exemplo sem socket real:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
void *atender_cliente(void *arg) {
int cliente_fd = *(int *)arg;
free(arg);
printf("Atendendo cliente %d\n", cliente_fd);
sleep(2);
printf("Cliente %d finalizado\n", cliente_fd);
return NULL;
}
int main(void) {
for (int i = 0; i < 5; i++) {
pthread_t t;
int *id = malloc(sizeof(int));
if (id == NULL) {
perror("malloc");
return 1;
}
*id = i;
if (pthread_create(&t, NULL, atender_cliente, id) != 0) {
perror("pthread_create");
free(id);
return 1;
}
pthread_detach(t);
}
sleep(5);
return 0;
}
Quando usar threads
Use threads quando:
- Várias tarefas compartilham muito estado.
- Você quer evitar o custo de criar processos.
- Você quer atender várias conexões dentro do mesmo processo.
- Você quer paralelizar o trabalho em múltiplos núcleos.
- Você quer manter uma tarefa bloqueante sem travar o programa inteiro.
Quando evitar threads
Evite ou tenha cuidado quando:
- O programa é simples e sequencial.
- O compartilhamento de estado ficará confuso.
- Você não quer lidar com condições de corrida.
- Você precisa de isolamento forte entre as tarefas.
- Um erro em uma tarefa não pode derrubar todo o programa.
Todas as threads pertencem ao mesmo processo. Portanto, se uma delas causar uma falha de segmentação (segmentation fault), todo o processo será encerrado.
Resumo
As threads compartilham a memória do processo, mas cada uma tem sua própria pilha e seu próprio fluxo de execução.
Sempre que duas threads acessarem o mesmo dado compartilhado e pelo menos uma delas realizar uma escrita, será necessário usar sincronização.