Semáforos Es un tipo de dato protegido que se utiliza para acceso exclusivo a recursos compartidos y para sincronización Introducido por Dijkstra a mediados de los 60 Si su valor es cero, el semáforo no está disponible Si su valor es positivo, está disponible Operaciones sobre semáforos: P (semáforo); V (semáforo); Existen semáforos con y sin nombre
Funciones asociadas Iniciar un semáforo sin nombre: #include int sem_init(sem_t *sem, int pshared, unsigned int value); sem identifica al semáforo pshared determina si sólo puede ser utilizado por hilos del mismo proceso (=0) o se puede compartir entre procesos (!=0) value es el valor inicial del semáforo Destruir un semáforo sin nombre int sem_destroy(sem_t *sem);
Funciones asociadas Iniciar un semáforo con nombre: sem_t *sem_open (const char *name, int oflag, … /* mode_t mode, int value */); La función devuelve un puntero al semáforo name debe tener el formato “/name” oflag indica las opciones O_CREAT: si el semáforo no existe, se crea. En este caso se requieren los permisos de acceso (mode) y el valor inicial (value) O_EXCL: si el semáforo existe se produce un error Cerrar un semáforo con nombre int sem_close(sem_t *sem);
Funciones asociadas Borrar un semáforo con nombre: int sem_unlink (const char *name); Operación P: int sem_wait(sem_t *sem); Si el semáforo está libre, lo toma, en caso contrario, el proceso se bloquea Operación P (con consulta): int sem_trywait(sem_t *sem); Toma el semáforo si está libre, en caso contrario devuelve error
Funciones asociadas Operación V (liberar un semáforo): int sem_post (sem_t *sem); Leer el valor de un semáforo: int sem_getvalue(sem_t *sem, int *sval);
Ejemplo #include #include #define SEM “/usr/people/chan/src/semaforo” main() { sem_t *sem; pid_t id; int i; sem = sem_open (SEM, O_CREAT, 666, 0); if ((int)sem == -1) { perror (“Error en sem_open”); } id = fork(); if (id == -1) { perror (“Error en el fork”);
Ejemplo exit (1); } if (id == 0) { for (i=1; i<20; i++) { printf (“Hijo %dn”, i); sem_post (sem); sleep (1); } } else { for (i=1; i<20; i++) { sem_wait (sem); printf (“Padre %dn”, i); } } } /* Fin de main */
Definición Es una información que se transfiere entre diferentes procesos o hilos mediante su inserción o extracción de una cola de mensajes Cada mensaje lleva asociada una prioridad Los mensajes se extraen de la cola de mensajes por orden de prioridad (no FIFO) Las colas de mensajes se identifican por medio de un nombre o un descriptor de cola de mensajes El envío de los mensajes puede ser bloqueante o no bloqueante en función de si el buffer está lleno o vacío
Atributos de las colas Estructura mq_attr Está declarada en typedef struct mq_attr { long mq_flags; /*O_NONBLOCK -> no bloqueante*/ long mq_maxmsg; /*número máximo de mensajes*/ long mq_msgsize; /*tamaño máximo del mensaje*/ long mq_curmsgs; /*actual número de mensajes*/ } mq_attr_t;
Funciones asociadas Abrir una cola de mensajes: mqd_t mq_open (const char *mq_name, int oflag, … /* mode_t mode, struct mq_attr *mq_attr */); La función devuelve un descriptor de cola mq_name debe ser del tipo “/name” oflag indica el modo de apertura Con O_CREAT mode especifica los derechos y mq_attr los atributos de creación
Funciones asociadas Cerrar una cola de mensajes: mqd_t mq_close (mqd_t mqd); Borrar una cola de mensajes: int mq_unlink (const char *mq_name); Definir los atributos de una cola: int mq_setattr (mqd_t mqd, struct mq_attr *mqstat, struct mq_attr *omqstat); Obtener los atributos de una cola: int mq_getattr (mqd_t mqd, struct mq_attr *mqstat);
Funciones asociadas Enviar un mensaje: int mq_send (mqd_t mqd, const char *msgptr, size_t msglen, unsigned int msg_prio); *msgptr es el puntero al mensaje msglen es su longitud msg_prio es la prioridad del mensaje Recibir un mensaje: int mq_receive (mqd_t mqd, char *msgptr, size_t msglen, unsigned int *msgprio);
Funciones asociadas Avisar de la llegada de un mensaje: int mq_notify (mqd_t mqd, const struct sigevent *notification); cuando llega el mensaje se avisa al proceso del evento sólo se puede avisar a un proceso si el proceso está esperando con mq_receive, la notificación no se produce
Ejemplo #include #include #include #define MQ “/usr/people/chan/src/mesgq” main() { struct mq_attr qattr; mqd_t qfd; pid_t id; int i; unsigned int Prio; char Mensaje[20];
Ejemplo qattr.mq_maxmsg = 32; qattr.mq_msgsize = 20; qfd = mq_open (MQ, O_CREAT|O_RDWR, 666, &qattr); if (qfd == -1) { perror (“Error en mq_open”); } id = fork(); if (id == -1) { perror ("Error en el fork"); exit (1); }
Ejemplo if (id == 0) { for (i=1; i<20; i++) { printf (“Hijo %dn”, i); mq_send (qfd, “Hola”, 5, 1); sleep (1); } } else { for (i=1; i<20; i++) { mq_receive (qfd, Mensaje, sizeof (Mensaje), &Prio); printf (“Padre %d – Mensaje %sn”, i, Mensaje); }
} } /* Fin de main */
Introducción Un thread es un flujo de control perteneciente a un proceso (a veces se habla de tareas con threads) Se les suele denominar también procesos ligeros, hebras, hilos, etc. La sobrecarga debida a su creación y comunicación es menor que en los procesos pesados Cada hilo pertenece a un proceso pesado Todos los hilos comparten su espacio de direccionamiento Cada hilo dispone de su propia política de planificación, pila y contador de programa
Introducción Cada hilo tiene su propio identificador tid que sólo es válido para hilos del mismo proceso Una aplicación con hilos puede beneficiarse de un procesamiento paralelo real en sistemas multiprocesador
Sistema Operativo Hardware Procesos pesados Hilos
Operaciones con hilos Creación y destrucción Sincronización Gestión de prioridades Gestión de señales Gestión de memoria Se pueden utilizar todas las funciones incluidas en POSIX.1 y POSIX.1b La interfaz de hilos POSIX es pthreads, aunque existen otras bibliotecas de hilos
Operaciones asociadas Crear un nuevo hilo: int pthread_create (pthread_t *thread, pthread_attr_t *attr, void *(*start)(void *), void *arg); En thread devuelve el identificador de hilo attr es un puntero a los atributos de la tarea El tercer argumento en un puntero a la función que ejecutará el hilo arg es un puntero a los argumentos del hilo Finalizar un hilo: void pthread_exit(void *retval);
Ejemplo #include void *Hilo (void *arg) { printf (“%sn”, (char *)arg); pthread_exit (0); } /* Fin de Hilo */
main() { pthread_t th1, th2; pthread_create (&th1, NULL, Hilo, “Hilo 1”); pthread_create (&th2, NULL, Hilo, “Hilo 2”); sleep(5); puts (“Adios: Hilo principal”); } /* Fin de main */
Atributos de los threads Los atributos definibles son: Tamaño de la pila Dirección de la pila Control de devolución de recursos Los atributos se crean con: int pthread_attr_init(pthread_attr_t *attr); Los atributos se destruyen con: int pthread_attr_destroy(pthread_attr_t *attr);
Definición y obtención de attr int pthread_attr_setstacksize(pthread_attr_t *attr, size_t size); int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size); int pthread_attr_setstackaddr(pthread_attr_t *attr, void *addr); int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **addr); int thread_attr_setdetachstate(pthread_attr_t *attr, int detach); int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detach);
Devolución de recursos Los hilos pueden operar en dos modos diferentes para controlar la devolución de recursos: Detached: opera de modo autónomo, cuando termina devuelve sus recursos (identificador, pila, etc.) Joinable: en su terminación mantiene sus recursos hasta que otro hilo invoca a pthread_join()
Devolución de recursos Los recursos de una tarea joinable se liberan cuando esperamos con pthread_join() int pthread_join(pthread_t thread, void **retval); Si la tarea opera en modo detached, el propio hilo al terminar libera sus recursos. Para convertir a un hilo en detached, si no se hizo en su inicio: int pthread_detach(pthread_t thread);
Ejemplo #include void *Hilo (void *arg) { printf (“%sn”, (char *)arg); sleep(3); pthread_exit (NULL); } /* Fin de Hilo */ main() { pthread_t th1, th2; void *st1; pthread_create (&th1, NULL, Hilo, "Hilo 1"); pthread_join (th1, (void **) &st1); printf (“Retorno del hilo: %dn”, st1); } /* Fin de main */
Identificación ¿Cómo obtener el identificador del hilo? pthread_t pthread_self(void); ¿Cómo comparar identificadores de hilo? int pthread_equal(pthread_t thread1, pthread_t thread2); Si los identificadores coinciden retorna TRUE, en caso contrario, FALSE
Cancelación En cualquier momento se puede solicitar la cancelación de un hilo Cuando se solicita la cancelación de un hilo se puede: Finalizar automáticamente el hilo Ignorar la petición y continuar Retrasar la finalización hasta llegar a un punto seguro
Funciones asociadas Solicitar la cancelación de un hilo: int pthread_cancel(pthread_t thread); Habilitar o inhabilitar la cancelación: int pthread_setcancelstate(int new_state, int *old_state); PTHREAD_CANCEL_ENABLE o PTHREAD_CANCEL_DISABLE Establecer el tipo de cancelación: int pthread_setcanceltype(int new_type, int *old_type); PTHREAD_CANCEL_ASYNCHRONOUS o PTHREAD_CANCEL_DEFERRED Verificar y terminar si se ha solicitado la cancelación: void pthread_testcancel(void);
Ejemplo #include void *Hilo (void *arg) { while(1) { printf (“%sn”, (char *)arg); sleep(1); } } /* Fin de Hilo */ main() { pthread_t th1; pthread_create (&th1, NULL, Hilo, “Hilo 1”); sleep(5); pthread_cancel(th1); printf(“Envío cancel al Hilo 1 …n”); sleep(5); } /* Fin de main */
| Página siguiente |