Desarrollador Profesional de Juegos Programación III Unidad III Mutex, Semáforos y Condicion de Sincronización Bajo Linux

Un caso práctico Consideremos dos variables compartidas x e y protegidas por el mutex mut y la condición cond que será señalizada cuando x sea mayor que y: int x,y; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER; Los threads que esperan, incluirán el siguiente código: // Bloqueo de la sección crítica pthread_mutex_lock (&mut); // En realidad bastaría un if, pero si hay varios threads... while(x<=y) { // Esperamos la señal.. pthread_cond_wait(&cond,&mut); } /* Aquí trabajaríamos con '''x''' y con '''y''' */ // los otros threads pueden continuar... pthread_mutex_unlock(&mut);

El thread que señaliza la condición tendría el código siguiente: críticapthread_mutex_lock(&mut); // Bloqueo de la sección /* Aquí trabajaríamos con '''x''' y con '''y''' */ // Señalo la condición. Si únicamente tuviera 1 thread en espera bastaría // pthread_cond_signal if (x>y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut); // Libero el mutex //Si quisieramos que la espera tuviera un timeout de 5 segundos: struct timeval now; struct timespec timeout; int retcode; pthread_mutex_lock(&mut); gettimeofday(&now); timeout.tv_sec=now.tv_sec+5; timeout.tv_nsec=now.tv_usec*1000; retcode=0; while ((x<=y) && (retcode != ETIMEDOUT)) { retcode=pthread_cond_timedwait(&cond,&mut,&timeout); } if (retcode == ETIMEDOUT) { /*Error,se acabo el tiempo (pasaron los 5 segundos) */} else { /* Trabajar con las variables '''x''' e '''y''' */ } pthread_mutex_unlock(&mut);

Cancelación de Threads La cancelación es un mecanismo por el que un thread puede provocar la finalización de otro enviándole una petición de finalización. Dependendo de la forma de trabajar del otro thread, puede ignorar la petición, finalizar inmediatamente o esperar alcanzar un punto de cancelación. Si el thread atiende inmediatamente la petición termina devolviendo el código PTHREAD_CANCELED. Los puntos de cancelación son puntos de ejecución donde se comprueba si hay peticiónes de cancelación pendientes. Las siguientes funcións tienen puntos de cancelación: pthread_join, pthread_cond_wait, pthread_cond_timedwait pthread_testcancel, sem_wait, sigwait. Las funcions de cancelación de thread son las siguientes: int pthread_cancel(pthread_t thread); int pthread_setcancelstate(int state, int *oldstate); int pthread_setcanceltype(int type,int *oldtype); int pthread_testcancel(void);

pthread_cancel envía una petición de cancelación al thread indicado como argumento. pthread_setcancelstate cambia el estado de cancelación del thread, es decir indica cuando se ignorarán las señales de cancelación y cando no. El parámetro state puede ser PTHREAD_CANCEL_ENABLE para permitir la cancelación o PTHREAD_CANCEL_DISABLE para no permitirla. Si el parámetro oldstate no es NULL, devolverá el estado de cancelación previo. pthread_setcanceltype cambia el tipo de respusta a las peticións de cancelación, y puede ser PTHREAD_CANCEL_ASYNCHRONOUS (para cancelación inmediata) o PTHREAD_CANCEL_DEFERRED (esperar al siguiente punto de cancelación). Si el parámetro oldtype no es NULL almacenará el tipo de cancelación anterior. pthread_testcancel únicamente sitúa un punto de cancelación en el lugar en que se llame. Los threads se créan por defecto con la cancelación activa con el tipo PTHREAD_CANCEL_DEFERRED

Envío y Gestion de Señales int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *oldmask); int pthread_kill(pthread_t thread, int signo); int sigwait(const sigset_t *set, int *sig); thread_sigmask cambia el conjunto de señales que va a respostar el thread. Si el parámetro oldmask no es NULL, almacenará el conjunto viejo de señales. Si how es SIG_SETMASK el conjunto de señales inicializa la newmask, si es SIG_BLOCK engádense las señales especificadas en newmask y si es SIG_UNBLOCK se quítan las señales especificadas en newmask del conjunto de señales los que va a respostar el thread. Los conjuntos de señales se manipulan con las funciónes:

int sigemptyset(sigset_t *conjunto); //vacía el conjunto de señales indicado int sigfillset(sigset_t *conjunto); //incluye todos los señales existentes en el conjunto indicado. int sigaddset(sigset_t *conjunto, int numseñal); //engaña a la señal indicada en el conjunto). int sigdelset(sigset_t *conjunto, int numseñal); // (elimina la señal indicad del conjunto). int sigismember(const sigset_t *conjunto, int numseñal); // (indica si el señal indicado pertence el conjunto). pthread_kill envía la señal signo al thread especificado. sigwait suspende el thread hasta que recibe una señal del conjunto indicado en set, almacenando entonces la señal recibida en sig. Se ignorará cualquier función asociada a la señal. Envío y Gestion de Señales