Practica 8 Paralela

Benemérita Universidad Autónoma de Puebla

Facultad de Ciencias de la Computación

Programación Concurrente y Paralela

Profa. Carmen Cerón Garnica

Práctica No. 8

INTRODUCCIÓN
Un monitor es un mecanismo de software para control de concurrencia que contiene los datos y los procedimientos necesarios para realizar la asignación de un determinado recurso o grupo de recursos compartidosreutilizables en serie.

OBJETIVO
Implementar monitores mediante el diseño de semáforos.

DESARROLLO
1. Dado los siguientes códigos contestar lo siguiente:

a) Explica que realiza el programa línea a línea y su ejecución final.

SEMÁFORO
public class Semaphore { /*DECLARA LA CLASE Semaphore*/
// contador de señales
private int s; /*DECLARA UNA VARIABLE PRIVADA ENTERA “s” PARAEL CONTADOR DE SEÑALES*/
// nombre de Threads bloquedos
private int esp; /*DECLARA LA VARIABLE ENTERA “esp” PARA EL NOMBRE DE LOS HILOS QUE ESTAN BLOQUEADOS*/

public Semaphore(int s) { /*DECLARA EL CONSTRUCTOR PARA INICIALIZAR VARIABLES*/
this.s = s; /*PASA EL VALOR DE s*/
esp = 0; /*INICIALIZA esp CON CERO*/
}

public synchronized void P(){ /*SE DECLARA UN METODO PUBLICOSINCRONIZADO QUE NO REGRESA NADA LLAMADA P() QUE HACE LO MISMO QUE EL METODO wait()*/
if (s == 0) { /*PREGUNTA SI s ES IGUAL A CERO PARA EJECUTAR LAS INSTRUCCIONES*/
esp++; /*INCREMENTA EL VALOR DE LA VARIABLE esp EN 1*/
try { wait(); } catch(InterruptedException e) {} /*ESPERA A QUE OCURRA UNA EXCEPCION PARA PODER EJECUTAR EL METODO wait()/*
} /* FIN DEL IF*/
else /*SI LACONDICON DEL IF ES FALSA ENTONCES..*/
s--; /*DECREMENTA s UNA VEZ*/}
public synchronized void V() { /*SE DECLARA UN METODO PUBLICO SINCRONIZADO QUE NO REGRESA NADA Y SE LLAMA “V” */
if (esp > 0) { /*SI esp ES MAYOR QUE CERO?*/
notify(); /*NOTIFICA A UN HILO DEL CONJUNTO DE ESPERA PARA PASARLO AL ESTADO LISTO*/
esp--; /*DECREMENTA LA VARIABLE esp EN 1*/
} /*FIN DELIF*/
else /*SI NO SE CUMPLE LA CONDICION DEL IF HACE*/
s++; /*INCREMENTA s UNA VEZ*/
} /*FIN DEL METODO V*/
} /*FIN DE LA CLASE Semaphore*/

MONITOR

class Monitor { /*DECLARA LA CLASE MONITOR
private Semaphore mon; /*DECLARA UNA VARIABLE PRIVADA DE TIPO Semaphore LLAMADA “mon”*/

protected Monitor() { /*CONSTRUCTOR PROTEGIDO QUE INICIALIZA LAS VARIABLES*/
mon = newSemaphore(1); /*CREA UN OBJETO DE LA CLASE Semaphore Y LE PASA EL VALOR DE UNO*/
} /*FIN DEL CONSTRUCTOR*/

protected void enter() { /*METODO PROTEGIDO QUE NO REGRESA NADA LLAMADO “enter”*/
mon.P(); /*EL OBJETO mon LLAMA AL METODO P() DE LA CLASE Semaphore*/
} /*FIN DEL METODO*/

protected void exit() { /*DECLARA UN METODO PROTEGIDO QUE NO REGRESA NADA LLAMADO “exit”*/mon.V(); /*EL OBJETO mon LLAMA AL METODO V() DE LA CLASE Semaphore*/
} /*FIN DEL METODO*/
protected Condition create_cond() { /*DECLARA UN METODO DE TIPO Condition QUE REGRESA UN OBJETO DE ESTE TIPO LLAMADO “create_cond()”*/
return new Condition(mon); /*CREA UN OBJETO Condition QUE LE PASA POR PARÁMETRO LA VARIBLE mon Y ADEMÁS RETORNA DICHO OBJETO*/
} /*FIN DEL METODO*/
} /*FINDE LA CLASE MONITOR*/

CONDITION

class Condition { /*DECLARA LA CLASE Condition*/
private Semaphore cond, mon; /*DECLARA DOS VARIABLES PRIVADAS DE TIPO Semaphore LLAMADAS “cond Y mon”*/
private int waiting; /*DECLARA UNA VARIABLE ENTERA LLAMADA “waiting”*/

public Condition(Semaphore mon) { /*ES EL CONSTRUCTOR Condition QUE LE PASA COMO PARAMETRO COMO OBJETO Semaphore*/
cond= new Semaphore(0); /*CREA UN OBJETO DE LA CLASE Semaphore*/
this.mon = mon; /*INICIALIZA LA VARIABLE mon DE LA CLASE, CON LA VARIABLE mon DEL CONSTRUCTOR*/
// waiting = 0;
} /*FIN DEL CONSTRUCTOR*/

public void wait_cond() // wait /*DECLARA UN METODO PUBLICO QUE NO REGRESA NADA LLAMADO “wait_cond()”*/
{
waiting++; /*INCREMENTA A waiting UNA VEZ*/
mon.V();...