POSIX Threads

Sincronización de hilos en POSIX: Mutex

Objetivos: Conocer los mecanismos de sincronización para acceso controlado a objetos compartidos.

Funciones POSIX para Sincronización
Estas funciones incluyen mecanismos de exclusión mutua (mutex), mecanismos de señalización del cumplimiento de condiciones por parte de variables, y mecanismos de acceso de variables que se modifican en forma exclusiva, pero pueden ser leídas en forma compartida. Las funciones para el manejo de zonas de acceso exclusivo tienen el prefijo pthread_mutex
Un mutex es una variable especial que puede tener estado tomado (locked) o libre (unlocked). Es como una compuerta que permite el acceso controlado. Si un hilo tiene el mutex entonces se dice que es el dueño del mutex. Si ningún hilo lo tiene se dice que está libre (o unclucked). Cada mutex tiene una cola de hilos que están esperando para tomar el mutex. El uso de mutex es eficiente, pero debería ser usado sólo cuando su acceso es solicitado por corto tiempo.

Función POSIX	Descripción
pthread_mutex_destroy	Destruye la variable (de tipo pthread_mutex_t) usada para manejo de exclusión mutua, o candado mutes
pthread_mutex_init	permite dar las condiciones iniciales a un candado mutex
pthread_mutex_lock	Permite solicitar acceso al mutex, el hilo se bloquea hasta su obtención
pthread_mutex_trylock	permite solicitar acceso al mutex, el hilo retorna inmediatamente. El valor retornado indica si otro hilo lo tiene.
pthread_mutex_unlock	Permite liberar un mutex.

Creación e iniciación de mutex

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t * mutex, const pthread_mutexattr_t * attr);

Alternativamente podemos invocar:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

lo cual inicializa el mutex con los atributos por omisión. Es el uso que daremos en este curso.
Es equivalente a invocar:
pthread_mutex_t mylock;
pthread_mutex_init(& mylock, NULL);

Destrucción de un mutex

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t * mutex);

Si el mutex lo tenía otro hilo y éste es destruido, POSIX no define el comportamiento de mutex en esta situación.

Solicitud y liberación de un mutex

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t * mutex);
int pthread_mutex_trylock(pthread_mutex_t * mutex);
int pthread_mutex_unlock(pthread_mutex_t * mutex);

Con pthread_mutex_trylock el hilo siempre retorna, si la función es exitosa, se retorna 0 -como en los otros casos; si no se retornará EBUSY indicando que otro hilo tiene el mutex.

Ejemplo: Para proteger una zona crítica, usar:
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_lock(&mylock);
/* Sección crítica */
pthread_mutex_unlock(&mylock);

Ejemplo:

Sin Mutex	Con Mutex
int counter=0; /* Function C */ void functionC() { counter++ }	/* Note scope of variable and mutex are the same / pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; int counter=0; / Function C */ void functionC() { pthread_mutex_lock( &mutex1 ); counter++ pthread_mutex_unlock( &mutex1 ); }

Sin Mutex

Con Mutex


int counter=0;

/* Function C */
void functionC()
{

   counter++

}

/* Note scope of variable and mutex are the same */
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter=0;

/* Function C */
void functionC()
{
   pthread_mutex_lock( &mutex1 );
   counter++
   pthread_mutex_unlock( &mutex1 );
}

Ejemplo: couter.c : conjunto de funciones para acceder a un contador a través de múltiples hilos.
Multiplicación de vectores sin threads y con threads.

Muchos llamados al sistema no son seguros de usar desde hilos (no son re-entrantes). strtok, rand, localtime, etc... Si necesitamos usar alguna de estas funciones, debemos considerarlas dentro de un código del tipo:

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

int randsafe(double *ranp) {
   static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
   int error;   

   if (error = pthread_mutex_lock(&lock))
      return error; 
   *ranp = (rand() + 0.5)/(RAND_MAX + 1.0);
   return pthread_mutex_unlock(&lock);

}

Ejemplo: programa que calcula la suma de valores aleatorios de la función sin(), en varios hilos, los suma muestra su resultados.

Mecanismos de sincronización Reader-writer
Estos mecanismos permiten acceso exclusivo para escritura pero accesos compartidos para lectura. También son conocidos como locks compartidos-exclusivos. La variable usada para proveer la sincronización en este caso es de tipo: pthread_rw_lock_t
Las funciones son:

Función POSIX	Descripción
pthread_rwlock_init	permite dar las condiciones iniciales a un candado de lectura y escritura.
pthread_rwlock_destry	Destruye la variable (de tipo pthread_rw_lock_t) usada para manejo de exclusión mutua, o candado read-write.
pthread_rwlock_wrlock	Permite solicitar acceso de escritura al candado, el hilo se bloquea hasta su obtención
pthread_rwlock_rdlock	permite solicitar acceso de lectura al candado, el hilo accede si el candado está libre o si sólo ha sido concedido para lectura.
pthread_rwlock_unlock	Permite liberar un candado read-write.
othread_rwlock_tryrdlock	Permite obtener el candado (lock) si está libre y retorna cero, en otro caso retorna EBUSY
pthread_rwlock_trywrlock	Permite obtener el candado (lock) si está libre y retorna cero, en otro caso retorna EBUSY

Evitando Deadlock
Como se estudio en Sistemas Operativos, la mala programación o uso de estos mecanismos de sincronización pueden conducir a Bloqueos Indefinidos (deadlock). Una forma simple de evitar esta situación es asegurar que cada hilo pida acceso a las zonas exclusivas siguiendo un orden común para todos los hilos. Si tenemos los candados a,b y c, todos los hilos los pedirán en ese orden. Otra opción es usar los tryxxlock, si es exitoso, OK; si no lo son se deben liberar locks previos, e intentar nuevamente.