Errores comunes con mutex

1. Olvidar el unlock

El error más común con mutex es olvidar liberar el lock. Esto ocurre cuando un hilo adquiere un mutex y no lo libera, por ejemplo, por un return anticipado o una condición de error:

void procesar(int *dato) {
    pthread_mutex_lock(&mutex);
    if (*dato < 0) {
        return;  /* BUG: se olvidó el unlock */
    }
    *dato *= 2;
    pthread_mutex_unlock(&mutex);
}

Si *dato < 0, la función retorna sin liberar el mutex. Los demás hilos que intenten adquirirlo se bloquearán para siempre (deadlock).

La solución es usar un patrón que garantice el unlock en todos los caminos:

void procesar(int *dato) {
    pthread_mutex_lock(&mutex);
    if (*dato < 0) {
        pthread_mutex_unlock(&mutex);  /* liberar antes de retornar */
        return;
    }
    *dato *= 2;
    pthread_mutex_unlock(&mutex);
}

O mejor aún, usar un solo punto de salida:

void procesar(int *dato) {
    int resultado = 0;
    pthread_mutex_lock(&mutex);
    if (*dato < 0) {
        resultado = -1;
        goto salir;
    }
    *dato *= 2;
salir:
    pthread_mutex_unlock(&mutex);
    return resultado;
}

2. Bloquear dos veces

Bloquear un mutex que ya está bloqueado por el mismo hilo causa un deadlock (con mutex normal):

void funcion_a(void) {
    pthread_mutex_lock(&mutex);
    funcion_b();  /* funcion_b también bloquea mutex */
    pthread_mutex_unlock(&mutex);
}

void funcion_b(void) {
    pthread_mutex_lock(&mutex);  /* DEADLOCK: mutex ya está bloqueado */
    /* ... */
    pthread_mutex_unlock(&mutex);
}

Este error es común cuando una función que bloquea un mutex llama a otra que también lo bloquea. La solución es usar un mutex recursivo (que permite bloquear múltiples veces por el mismo hilo) o reestructurar el código para evitar el doble bloqueo.

3. trylock

pthread_mutex_trylock intenta adquirir el mutex sin bloquear. Si el mutex está libre, lo adquiere y retorna 0. Si está ocupado, retorna EBUSY inmediatamente:

int ret = pthread_mutex_trylock(&mutex);
if (ret == 0) {
    /* Se adquirió el mutex. */
    /* ... sección crítica ... */
    pthread_mutex_unlock(&mutex);
} else if (ret == EBUSY) {
    /* El mutex está ocupado. Hacer otra cosa. */
    hacer_trabajo_alternativo();
} else {
    /* Error. */
    perror("pthread_mutex_trylock");
}

trylock es útil cuando el hilo tiene trabajo alternativo que puede hacer mientras espera, o cuando se quiere evitar el bloqueo (por ejemplo, en un bucle de eventos).

4. timedlock

pthread_mutex_timedlock intenta adquirir el mutex con un timeout. Si no se puede adquirir en el tiempo especificado, retorna ETIMEDOUT:

#include <time.h>

struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5;  /* timeout de 5 segundos */

int ret = pthread_mutex_timedlock(&mutex, &ts);
if (ret == 0) {
    /* Se adquirió el mutex. */
    pthread_mutex_unlock(&mutex);
} else if (ret == ETIMEDOUT) {
    /* Timeout: no se pudo adquirir en 5 segundos. */
    printf("Timeout esperando el mutex\n");
} else {
    perror("pthread_mutex_timedlock");
}

timedlock es útil cuando se quiere evitar esperas indefinidas: si el mutex no se puede adquirir en un tiempo razonable, el hilo puede tomar una acción alternativa (como reportar un error o reintentar).

5. Tipos de mutex

pthread ofrece varios tipos de mutex, configurables con pthread_mutexattr_settype:

6. Mutex errorcheck

El mutex errorcheck detecta errores comunes y retorna un código de error en lugar de causar un deadlock:

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
pthread_mutex_init(&mutex, &attr);

/* Bloquear dos veces: retorna EDEADLK en lugar de deadlock. */
int ret = pthread_mutex_lock(&mutex);
if (ret != 0) {
    /* Error. */
}
ret = pthread_mutex_lock(&mutex);  /* EDEADLK */
if (ret == EDEADLK) {
    printf("Deadlock detectado!\n");
}

/* Desbloquear sin haber bloqueado: retorna EPERM. */
pthread_mutex_unlock(&mutex);  /* EPERM */

El mutex errorcheck es más lento que el normal (por la verificación adicional), pero es invaluable para detectar errores durante el desarrollo.

7. Mutex recursivo

El mutex recursivo permite que el mismo hilo bloquee el mutex múltiples veces. Cada lock incrementa un contador; cada unlock lo decrementa. El mutex se libera cuando el contador llega a 0:

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex, &attr);

void funcion_a(void) {
    pthread_mutex_lock(&mutex);  /* contador = 1 */
    funcion_b();
    pthread_mutex_unlock(&mutex);  /* contador = 0, se libera */
}

void funcion_b(void) {
    pthread_mutex_lock(&mutex);  /* contador = 2 */
    /* ... */
    pthread_mutex_unlock(&mutex);  /* contador = 1 */
}

El mutex recursivo es útil para funciones recursivas que bloquean el mismo mutex. Pero puede ocultar errores de diseño: si una función bloquea y otra libera, el contador puede quedar en un estado inconsistente.

8. Mutex normal (default)

El mutex normal (PTHREAD_MUTEX_NORMAL) es el más rápido pero el menos seguro:

• Bloquear dos veces: deadlock inmediato.
• Desbloquear sin haber bloqueado: comportamiento indefinido (puede corromper el estado del mutex).
• Desbloquear desde otro hilo: comportamiento indefinido.

El mutex normal es el que se usa en la práctica (es el default), pero requiere disciplina del programador: siempre bloquear y desbloquear en el mismo hilo, y nunca bloquear dos veces.

9. Patrones seguros

Los patrones seguros para usar mutex son:

1. Lock/unlock en el mismo ámbito: bloquear al inicio de una función y desbloquear al final. simple
2. RAII (Resource Acquisition Is Initialization): en C++, usar un objeto que bloquea en el constructor y desbloquea en el destructor. C++
3. Un solo punto de salida: usar goto para unificar el desbloqueo. goto
4. trylock con reintento: usar trylock en un bucle con backoff. trylock

El patrón más seguro en C es el de un solo punto de salida:

int procesar(int *dato) {
    int resultado = 0;
    pthread_mutex_lock(&mutex);
    if (*dato < 0) {
        resultado = -1;
        goto salir;
    }
    *dato *= 2;
salir:
    pthread_mutex_unlock(&mutex);
    return resultado;
}

10. Herramientas de detección

Las herramientas para detectar errores con mutex son:

• ThreadSanitizer: detecta carreras de datos y mal uso de mutex (bloqueo dos veces, desbloqueo sin bloquear).
• Helgrind: detecta mal uso de mutex y condiciones de carrera.
• Valgrind --tool=drd: más rápido que Helgrind, detecta carreras.
• Clang Static Analyzer: análisis estático que detecta posibles deadlocks.

ThreadSanitizer es la herramienta más usada en la práctica. Se compila con -fsanitize=thread y detecta errores en tiempo de ejecución.

11. Simulador interactivo

Este simulador muestra los errores comunes con mutex y cómo detectarlos:

12. Resumen

• Olvidar el unlock es el error más común: causa deadlock.
• Bloquear dos veces un mutex normal causa deadlock inmediato.
• trylock intenta adquirir sin bloquear; timedlock con timeout.
• Los tipos de mutex son: NORMAL, ERRORCHECK, RECURSIVE, DEFAULT.
• ERRORCHECK detecta errores en tiempo de ejecución.
• RECURSIVE permite bloquear múltiples veces por el mismo hilo.
• Los patrones seguros garantizan que cada lock tenga su unlock.
• ThreadSanitizer y Helgrind detectan errores con mutex.

13. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Escribe un programa que olvide el unlock y observa el deadlock.
2. Usa un mutex errorcheck y verifica que detecta el doble lock.
3. Implementa trylock en un bucle con backoff.
4. Implementa timedlock con un timeout de 1 segundo.
5. Usa ThreadSanitizer para detectar un error con mutex.
6. Investiga cómo Helgrind detecta deadlocks.