## Monitores Java

El lenguaje Java y el sistema de ejecución soportan la sincronizaxión de threads mediante el uso de monitores. En general, un monitor está asociado con un objeto especifico (una condición variable) y funciona como un bloqueo para ese dato. Cuando un thread mantiene el monitor para algún dato del objeto, los otros threads están bloqueados y no pueden ni inspeccionar ni modificar el dato.

Los segmentos de código dentro de programa que acceden al mismo dato dentro de threads concurrentes separados son conocidos como secciones críticas. En el lenguaje Java, se pueden marcar las secciones críticas del programa con la palabra clave synchronized.

Nota: Generalmente, la sección críticas en los programas Java son métodos. Se pueden marcar segmentos pequeños de código como sincronizados. Sin embargo, esto viola los paradigmas de la programación orientada a objetos y produce un código que es díficil de leer y de mantener. Para la mayoría de los propósitos de programación en Java, es mejor utilizar synchronized sólo a nivel de métodos.

En el lenguaje Java se asocia un único monitor con cada objeto que tiene un método sincronizado. La clase CubbyHole del ejemplo Producer/Consumer de la página anterior tiene dos métodos sincronizados: el método put(), que se utiliza para cambiar el valor de CubbyHole, y el método get(), que se utiliza para el recuperar el valor actual. Así el sistema asocia un único monitor con cada ejemplar de CubbyHole.

Aquí tienes el código fuente del objeto CubbyHole. Las líneas en negrita proporcionan la sincronización de los threads:

    class CubbyHole {
        private int contents;
        private boolean available = false;

        public synchronized int get() {
            while (available == false) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
            available = false;
            notify();
            return contents;
        }

        public synchronized void put(int value) {
            while (available == true) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
            contents = value;
            available = true;
            notify();
        }
    }

La clase CubbyHole tiene dos variables privadas: contents, que es el contenido actual de CubbyHole, y la variable booleana available, que indica si se puede recuperar el contenido de CubbyHole. Cuando available es verdadera indica que el Productor ha puesto un nuevo valor en CubbyHole y que el Consumidor todavía no la ha consumido. El Consumidor sólo puede consumir el valor de CubbyHole cuando available es verdadera.

Como CubbyHole tiene dos métodos sincronizados, java proporciona un único monitor para cada ejemplar de CubbyHole (incluyendo el compartido por el Productor y el Consumidor). Siempre que el control entra en un método sincronizado, el thread que ha llamado el método adquiere el monitor del objeto cuyo método ha sido llamado. Otros threads no pueden llamar a un método sincronizado del mismo objeto hasta que el monitor sea liberado.

Nota: Los Monitores Java son Re-entrantes. Esto es, el mismo thread puede llamar a un método sincronizado de un objeto para el que ya tiene el monitor, es decir, puede re-adquirir el monitor.

Así, siempre que el Productor llama al método put() de CubbyHole, adquiere el monitor del objeto CubbyHole, y así evita que el consumidor pueda llamar al método get() de CubbyHole. (El método wait() libera temporalmente el monitor como se verá más adelante).

    public synchronized void put(int value) {
            // El productor adquiere el monitor
        while (available == true) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        contents = value;
        available = true;
        notify();
            // El productor libera el monitor
    }

Cuando el método put() retorna, el Productor libera el monitor y por lo tanto desbloquea el objeto CubbyHole.

Siempre que el Consumidor llama al método get() de CubbyHole, adquiere el monitor de ese objeto y por lo tanto evita que el productor pueda llamar al método put().

    public synchronized int get() {
            // El consumidor adquier el monitor
        while (available == false) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        available = false;
        notify();
        return contents;
            // el Consumidor libera el monitor
    }

La adquisición y liberación del monitor la hace automáticamente el sistema de ejecución de Java. Esto asegura que no puedan ocurrir condiciones de competición en la implementación de los threads, asegurando la integridad de los datos.

Prueba esto: Elimina las líneas que están en negrita en el listado de la clase CubbyHole mostrada arriba. Recompila el programa y ejecutalo de nuevo. ¿Qué sucede? Como no se ha realizado ningún esfuerzo explícito para sicronizar los threads, el Consumidor consume con un abandono temerario y obtiene sólo una ristra de ceros, en lugar de obtener los enteros entre 0 y 9 exactamente una vez cada uno.

Ozito