Sincronización y condiciones de carrera

Cuando varios hilos acceden a recursos compartidos, pueden producirse condiciones de carrera que provoquen resultados impredecibles.

En esta lección, aprenderá:

• Qué son las condiciones de carrera y cómo se producen.
• Cómo utilizar mutexes para evitar condiciones de carrera.
• Cómo ayudan los semáforos a gestionar los recursos compartidos.

¿Qué es una condición de carrera?

Una condición de carrera se produce cuando varios hilos acceden simultáneamente a datos compartidos, lo que provoca un comportamiento impredecible.

Ejemplo:

• Dos hilos intentan actualizar un contador global.
• El valor final puede ser incorrecto debido a la interferencia.

Ejemplo: condición de carrera en el multihilo

Este programa muestra una condición de carrera en la que varios hilos modifican una variable compartida.

#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;
}

Cómo evitar condiciones de carrera con un mutex

Un mutex (exclusión mutua) garantiza que solo un hilo acceda a un recurso cada vez.

Funciones de mutex:

• pthread_mutex_init() - Inicializa un mutex.
• pthread_mutex_lock() - Bloquea el mutex.
• pthread_mutex_unlock() - Desbloquea el mutex.
• pthread_mutex_destroy() - Destruye el mutex.

Ejemplo: uso de un mutex para evitar condiciones de carrera

Este programa corrige la condición de carrera mediante un mutex que controla el acceso al contador compartido.

#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;
}

¿Qué es un semáforo?

Un semáforo es un contador que se utiliza para controlar el acceso a los recursos.

Funciones principales:

• sem_init() - Inicializa un semáforo.
• sem_wait() - Disminuye el valor del semáforo.
• sem_post() - Aumenta el valor del semáforo.
• sem_destroy() - Destruye el semáforo.

Ejemplo: uso de semáforos para la sincronización

Este programa utiliza un semáforo para gestionar el acceso a un recurso compartido.

#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ácticas recomendadas para sincronizar hilos

Para evitar condiciones de carrera:

• Utilice mutexes para proteger las variables compartidas.
• Utilice semáforos para gestionar los recursos.
• Minimice el uso de recursos compartidos siempre que sea posible.

Resumen

En esta lección, aprenderá:

• Qué son las condiciones de carrera y cómo se producen.
• Cómo utilizar mutexes para evitar condiciones de carrera.
• Cómo ayudan los semáforos a gestionar el acceso a los recursos compartidos.

Con esto concluye la sección sobre multihilo y concurrencia en C.