Sincronização e condições de corrida

Quando várias linhas de execução acessam recursos compartilhados, podem ocorrer condições de corrida, levando a resultados imprevisíveis.

Nesta lição, você aprenderá:

• O que são condições de corrida e como elas ocorrem.
• Como usar mecanismos de exclusão mútua para evitar condições de corrida.
• Como os semáforos ajudam a gerenciar recursos compartilhados.

O que é uma condição de corrida?

Uma condição de corrida ocorre quando várias linhas de execução acessam dados compartilhados simultaneamente, levando a um comportamento imprevisível.

Exemplo:

• Duas linhas de execução tentam atualizar um contador global.
• O valor final pode estar incorreto devido à interferência.

Exemplo: condição de corrida na execução com múltiplas linhas

Este programa demonstra uma condição de corrida na qual várias linhas de execução modificam uma variável compartilhada.

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

int counter = 0;

void *incrementCounter(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, incrementCounter, NULL);
    pthread_create(&t2, NULL, incrementCounter, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Final counter value: %d\n", counter);
    return 0;
}

Evitando condições de corrida com exclusão mútua

Um mecanismo de exclusão mútua garante que apenas uma linha de execução acesse um recurso por vez.

Funções de exclusão mútua:

• pthread_mutex_init() - Inicializa um mecanismo de exclusão mútua.
• pthread_mutex_lock() - Bloqueia o mecanismo de exclusão mútua.
• pthread_mutex_unlock() - Desbloqueia o mecanismo de exclusão mútua.
• pthread_mutex_destroy() - Destrói o mecanismo de exclusão mútua.

Exemplo: usando exclusão mútua para evitar condições de corrida

Este programa corrige a condição de corrida usando exclusão mútua para controlar o acesso ao contador compartilhado.

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

int counter = 0;
pthread_mutex_t lock;

void *incrementCounter(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock, NULL);
    pthread_create(&t1, NULL, incrementCounter, NULL);
    pthread_create(&t2, NULL, incrementCounter, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_mutex_destroy(&lock);
    printf("Final counter value: %d\n", counter);
    return 0;
}

O que é um semáforo?

Um semáforo é um contador usado para controlar o acesso a recursos.

Principais funções:

• sem_init() - Inicializa um semáforo.
• sem_wait() - Diminui o valor do semáforo.
• sem_post() - Aumenta o valor do semáforo.
• sem_destroy() - Destrói o semáforo.

Exemplo: usando semáforos para sincronização

Este programa usa um semáforo para gerenciar o acesso a um recurso compartilhado.

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

sem_t sem;

void *task(void *arg) {
    sem_wait(&sem);
    printf("Thread %d is executing\n", *(int *)arg);
    sem_post(&sem);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    int id1 = 1, id2 = 2;
    sem_init(&sem, 0, 1);
    pthread_create(&t1, NULL, task, &id1);
    pthread_create(&t2, NULL, task, &id2);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    sem_destroy(&sem);
    return 0;
}

Práticas recomendadas para sincronizar linhas de execução

Para evitar condições de corrida:

• Use mecanismos de exclusão mútua para proteger variáveis compartilhadas.
• Use semáforos para gerenciar recursos.
• Minimize o uso de recursos compartilhados sempre que possível.

Resumo

Nesta lição, você aprendeu:

• O que são condições de corrida e como elas ocorrem.
• Como usar mecanismos de exclusão mútua para evitar condições de corrida.
• Como os semáforos ajudam a gerenciar o acesso a recursos compartilhados.

Isso conclui a seção Execução com múltiplas linhas e concorrência em C!