Diferencia entre revisiones de «Monitores»

Revisión del 20:17 16 nov 2011

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

• Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
• El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
• No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
• Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

Definición

Un monitor es una estructura del lenguaje cuyas principales características son:

• Los datos son privados.
• Ofrecen una serie de métodos públicos para acceder a dichos datos.
• En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

• Variables de condición: lista de procesos inicialmente vacía.
• Primitivas: wait(c), añade el proceso p invocante a c y proceso p bloquea; signal(c), selecciona a uno de los procesos en c y lo pone en preparado.

class recursoCompartido {

    public int get(void);
    public void set(int valor);
    private int recursoCompartido;
    private Semaforo s = 1;

    public int get(void){
        int ret;
        down(s);
        ret = recursoCompartido;
        up(s);
        return ret;
    }

    public void set(int valor){
        down(s);
        recursoCompartido = valor;
        up(s);
    }
}

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

Ejemplo de uso de un Monitor

Dado recurso compartido de ejemplo (expresado en pseudocódigo cercano a Java):

• RecursoCompartido r = new RecursoCompartido();

Y dados los dos hilos de ejemplo siguiente:

• Lector (h1):

 int valor;
 while(1){ //1
  valor=r.get(); //2
  print(valor); //3

}

• Escritor (h2):

  int i=0;
  while(1){ //1
    r.set(); //2
    i++; //3

}

Su traza sería:

       Datos del problema: - R.R estricto, con q=4
                           - El h1 pasa a activo en primer lugar.

            
           

                       < = lanzamiento del proceso
                       > = finalización del proceso                                                                       
                       x = indica que el proceso está asignado al procesador en ese momento.
                       * = el proceso bloquea.
                                           
                              recurso procesador
        | 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
    h1  <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
        |---|---|---|---| 1 |2.1|---|---|---|---|---|
    h2  |---|---|---|---<xxx|xxx*---|---|---|---|---|
       -----|---|---|---|---|---|---|---|---|---|---|---> t
        0   1   2   3   4   5   6   7   8   9   10  11  
 
         Nota: Los números de la parte superior a las x, indican el número de instrucción que 
               se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se 
               refieren al número de instrucción qué internamente se ejecutan en el get() y set() 
               del monitor. 

      

En la página de discusión hay un ejemplo en java.

Fuentes

<references/>