Monitores Programacin Concurrente y Paralela Definicin Un monitor

Monitores Programación Concurrente y Paralela

Definición � Un monitor es un conjunto de procedimientos que proporciona el acceso con exclusión mutua a un recurso o conjunto de recursos (datos o dispositivos) compartidos por un grupo de procesos. � Los procedimientos van encapsulados dentro de un módulo que tiene la propiedad especial de que sólo un proceso puede estar activo cada vez para ejecutar un procedimiento del monitor. � Es activado (o utilizado) mediante llamadas desde los procesos.

Estructura del Monitor v Monitor: la estructura y la sintaxis Negociación Monitor <nombre> { public: <lista_Proc_Públicos>; Recursos Privados private: <decl_Recurso_Priv>; Procedimientos Públicos (Procedimientos Privados) <implementación_Proc> Cuerpo body: <inic_Val_Recursos>; Liberación }

Sintaxis del Monitor Nombre o Indentificador Lista de los procedimientos que Pueden invocar los procesos. Ej. public: sumar, restar; Monitor <nombre> { public: <lista_Proc_Públicos>; private: <decl_Recurso_Priv>; Declaración de los recursos privados que los procesos utilizaran para Comunicarse y sincronizarse Ej. private: int X; float total. Cant; <implementación_Proc> body: <inic_Val_Recursos>; } Implementación de los Procedimientos públicos y privados del monitor Sintaxis <tipo> <nomb>(<par>) { <sent>; } El cuerpo es el conjunto de sentencias para inicializar los recursos Ej: int sumar(int a, b) { return a+b; } Invocación: <nomb. Mon>. <nom. Proc>

¿Cómo funciona el monitor? Ø Los procesos, cuando desean comunicarse o sincronizarse utilizan los recurso privados del Monitor, mediante invocación de los procedimientos públicos. Ø Antes de que se pueda ejecutar ningún procedimiento del Monitor se ejecuta el cuerpo. Ø Si un proceso invoca un procedimiento de un Monitor, y no existe ningún otro proceso ejecutando alguno de sus procedimientos, éste proceso bloquea y ocupa el Monitor, ejecuta el procedimiento. Ø Si un proceso invoca algún procedimiento del Monitor, y éste está ocupado, el proceso queda bloqueado en una cola asociada al Monitor Ø Cuando un proceso finaliza la ejecución de un procedimiento del Monitor, se analiza la cola del Monitor, seleccionando el primer proceso bloqueado en ella.

Variable Condición � Una variable que se utilice como mecanismo de sincronización en un monitor se conoce como variable de condición. � Un proceso deba esperar se asocia una variable de condición. Sobre ellas sólo se puede actuar con dos � procedimientos: espera y señal. En este caso, cuando un proceso ejecuta una operación de espera se suspende y se coloca en una cola asociada a dicha variable de condición. � La diferencia con el semáforo estriba en que ahora la ejecución de esta operación siempre suspende el proceso que la emite. La suspensión del proceso hace que se libere la posesión del monitor, lo que permite que entre otro proceso.

¿Cómo trabaja el monitor? � Cuando un proceso ejecuta una operación de señal se libera un proceso suspendido en la cola de la variable de condición utilizada. Si no hay ningún proceso suspendido en la cola de la variable de condición invocada la operación señal no tiene ningún efecto. � El monitor no tiene por qué exportar todos sus procedimientos sino sólo aquellos que sean públicos y manteniendo como privados aquellos a los que sólo pueden acceder otros procedimientos definidos dentro del monitor.

¿Cómo trabaja el monitor? � � El primer proceso que realiza una invocación a la operación sespera puede acceder al recurso controlado por el monitor y como la variable ocupado se pone a verdadero, cualquier otro proceso que ejecute la operación sespera debe esperar a que se ejecute una operación sseñal para poder acceder al recurso. Cuando esto ocurre la variable ocupado pasa a tener el valor falso y la condición libre recibe una señal, lo que hace que uno de los procesos que esperan en su cola pase a completar la ejecución de sespera y pueda acceder al recurso. Ejecuciones sucesivas de sseñal van despertando a procesos en espera hasta que no haya más procesos en la cola de la condición libre. Cuando no hay ningún proceso en espera de la variable de condición la ejecución de sseñal sólo tiene por efecto poner la variable ocupado a false, lo que permite que el primer proceso que ejecute sespera pueda acceder al recurso.

Ejemplos clásicos v Filósofos N(=5) Procesos: Pensar - Comer MONITOR Palillos Disponibles de Cada Filósofo Coger Palillos Dejar Palillos

Monitor Ctrl. Palillos { public coger. Palillos, dejar. Palillos; private int num. Palillos[5]; condition dormir[5]; void coger. Palillos(int filosofo) { if (num. Palillos[filosofo] != 2) dormir[filosofo]. delay(); num. Palillos[ (filofoso+5 -1)%5 ]--; num. Palillos[ (filofoso+1)%5 ]--; } void dejar. Palillos(int filosofo) { num. Palillos[ (filofoso+5 -1)%5 ]++; num. Palillos[ (filofoso+1)%5 ]++; if (num. Palillos[(filofoso+5 -1)%5]==2) dormir[(filofoso+5 -1)%5]. resume(); if (num. Palillos[(filofoso+1)%5 ]==2) dormir[(filofoso+1)%5]. resume(); } Body: for(int i=0; i<5; i++) num. Palillos=2; }

v Exclusión Mutua en Java Ø Simulación de un Monitor class ej. Monitor { // Atributos privados // Métodos Synchronized públicos public synchronized void met 1() { // código synchronized }. . . public synchronized void met. N() { // código synchronized } }

v Sincronización en Java Los objetos en Java disponen de un mecanismo parecido (aunque con diferencias) a las variables de condición de los Monitores Cada objeto sólo dispone de una variable de condición, denominada conjunto de espera (wait set). – Un hilo que haya adquirido el “cerrojo” del objeto puede detenerse en ella. Liberando el cerrojo. – Los hilos detenidos en una espera, cuando son seleccionados deben competir, de nuevo, por el “cerrojo”. – Bloqueo en el conjunto de espera: wait(); . . . try { wait(); } catchg (Interrupted. Exception e) { }. . . Activación de un hilo del conjunto de espera: notify() o notify. All()

v Sincronización en Java Uso tradicional while ( ! cond ) { try { wait(); }catch(Interrupted. Exception e) {} } try-catch: el método wait puede lanzar un excepción en caso de producirse una interrupción. while (en lugar de if): - Los hilos deben volver a adquirir el cerrojo - Existe una única variable de condición

v Diferencias entre Monitores y el Modelo Java Ø Semántica de c. resume() vs notify() Monitor: Un proceso despertado tiene preferencia sobre otros que desean acceder al Monitor Java: Ø Un hilo despertado debe volver a adquirir el cerrojo, no garantizándose su continuación inmediata Objetos vs Variables de Condición Monitor: Facilidad de utilización de múltiples variables de condición. Java: Un objeto sólo dispone de un conjunto de espera La simulación de múltiples conjuntos de espera requiere gran habilidad del programador

v v Ventajas de Monitores Ø Enfoque Modular Ø Facilidad de uso Inconvenientes Ø v Modelo de sincronización Mejora Ø Monitor (Exclusión Mutua) + RCC (Sincronización)

Métodos de espera y notificación Java � En Java no existe el concepto de variable condición. Podríamos decir que cada monitor en Java tiene una única variable condición anónima. Los monitores de Java implementan la disciplina signal and continue. � Los metodos wait(), notify() y notify. All() implementan los mecanismos de espera y notificación de los monitores Java. Estos métodos solamente pueden ser llamados por una hebra cuando esta posee el cerrojo del objeto, es decir, desde un bloque o un método sincronizado.

� � La invocacion al metodo wait() provoca que la hebra actual se bloquee y sea colocada en una cola de espera asociada al objeto monitor. El cerrojo del objeto es liberado, para que otras hebras puedan ejecutar métodos del objeto. Sin embargo, otros cerrojos poseidos por la hebra suspendida son retenidos por esta. La invocacion al metodo notify() provoca que, si hay alguna hebra bloqueada en wait(), se escoja una cualquiera de forma arbitraria, y se saque de la cola de wait() pasando esta al estado preparado. La hebra que invoco notify() seguirá ejecutándose dentro del monitor. La hebra señalada deberá adquirir el cerrojo del objeto para poder ejecutarse. Esto significara esperar al menos hasta que la hebra que invoco notify() libere el cerrojo, bien por la ejecución de una llamada a wait(), o bien por la salida del monitor. La hebra señalada no tiene prioridad alguna para ejecutarse en el monitor.

� Puede ocurrir que, antes de que la hebra señalada pueda volver a ejecutarse, otra hebra adquiera el cerrojo del monitor. � La invocación al método notify. All() produce el mismo resultado que una llamada a notify() por cada hebra bloqueada en la cola de wait(): todas las hebras bloqueadas pasan al estado preparado