Threads são uma parte essencial da programação moderna, permitindo a execução de múltiplas tarefas em paralelo dentro de um único processo. No ambiente Linux, as threads são implementadas seguindo o padrão POSIX (Portable Operating System Interface), que define uma API para compatibilidade entre sistemas Unix-like. Utilizar threads POSIX em Linux é crucial para desenvolver aplicações eficientes e responsivas.

Neste artigo, vamos explorar como criar e gerenciar threads POSIX em um sistema Linux. Vamos fornecer exemplos práticos que demonstram a criação, sincronização e gerenciamento de threads usando a biblioteca pthreads, que é a implementação POSIX de threads em Linux.

Exemplos:

1. Criando uma Thread Simples

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void* thread_function(void* arg) {
    printf("Olá do thread!\n");
    return NULL;
}

int main() {
    pthread_t thread;
    int result;

    result = pthread_create(&thread, NULL, thread_function, NULL);
    if (result != 0) {
        perror("Falha ao criar thread");
        exit(EXIT_FAILURE);
    }

    pthread_join(thread, NULL);
    return 0;
}

Neste exemplo, criamos uma thread que executa a função thread_function e imprime uma mensagem. A função pthread_create é usada para criar a thread, e pthread_join é usada para esperar que a thread termine.

2. Sincronizando Threads com Mutex

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_mutex_t lock;

void* thread_function(void* arg) {
    pthread_mutex_lock(&lock);
    printf("Thread %d está na seção crítica\n", *((int*)arg));
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[5];
    int thread_ids[5];

    pthread_mutex_init(&lock, NULL);

    for (int i = 0; i < 5; i++) {
        thread_ids[i] = i;
        pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]);
    }

    for (int i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock);
    return 0;
}

Neste exemplo, usamos um mutex para sincronizar o acesso à seção crítica. A função pthread_mutex_lock bloqueia o mutex, e pthread_mutex_unlock o libera, garantindo que apenas uma thread possa acessar a seção crítica por vez.

3. Usando Variáveis de Condição

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_mutex_t lock;
pthread_cond_t cond;
int ready = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&lock);
    while (!ready) {
        pthread_cond_wait(&cond, &lock);
    }
    printf("Thread %d está processando\n", *((int*)arg));
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[5];
    int thread_ids[5];

    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);

    for (int i = 0; i < 5; i++) {
        thread_ids[i] = i;
        pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]);
    }

    sleep(1); // Simula alguma preparação
    pthread_mutex_lock(&lock);
    ready = 1;
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&lock);

    for (int i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    return 0;
}

Neste exemplo, usamos uma variável de condição para sincronizar as threads. A função pthread_cond_wait faz a thread esperar até que a condição seja sinalizada, enquanto pthread_cond_broadcast acorda todas as threads esperando pela condição.