Threads de Control

El lenguaje Java y el sistema de ejecucin soportan la sincronizaxin de threads mediante el uso de monitores. En general, un monitor est asociado con un objeto especifico (una condicin variable) y funciona como un bloqueo para ese dato. Cuando un thread mantiene el monitor para algn dato del objeto, los otros threads estn bloqueados y no pueden ni inspeccionar ni modificar el dato.

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

Nota: Generalmente, la seccin crticas en los programas Java son mtodos. Se pueden marcar segmentos pequeos de cdigo como sincronizados.

Sin embargo, esto viola los paradigmas de la programacin orientada a objetos y produce un cdigo que es dficil de leer y de mantener. Para la mayora de los propsitos de programacin en Java, es mejor utilizar synchronized slo a nivel de mtodos.

En el lenguaje Java se asocia un nico monitor con cada objeto que tiene un mtodo sincronizado. La clase CubbyHole del ejemplo Producer/Consumer de la pgina anterior tiene dos mtodos sincronizados: el mtodo put(), que se utiliza para cambiar el valor de CubbyHole, y el mtodo 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 cdigo fuente del objeto CubbyHole. Las lneas en negrita proporcionan la sincronizacin 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 todava no la ha consumido. El Consumidor slo puede consumir el valor de CubbyHole cuando available es verdadera.

Como CubbyHole tiene dos mtodos 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 mtodo sincronizado, el thread que ha llamado el mtodo adquiere el monitor del objeto cuyo mtodo ha sido llamado. Otros threads no pueden llamar a un mtodo sincronizado del mismo objeto hasta que el monitor sea liberado.

Nota:

Los Monitores Java son Re-entrantes.

Es decir, el mismo thread puede llamar a un mtodo 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 mtodo put() de CubbyHole, adquiere el monitor del objeto CubbyHole, y as evita que el consumidor pueda llamar al mtodo get() de CubbyHole. (El mtodo wait() libera temporalmente el monitor como se ver ms 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 mtodo put() retorna, el Productor libera el monitor y por lo tanto desbloquea el objeto CubbyHole.

Siempre que el Consumidor llama al mtodo get() de CubbyHole, adquiere el monitor de ese objeto y por lo tanto evita que el productor pueda llamar al mtodo 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 adquisicin y liberacin del monitor la hace automticamente el sistema de ejecucin de Java. Esto asegura que no puedan ocurrir condiciones de competicin en la implementacin de los threads, asegurando la integridad de los datos.

Prueba esto: Elimina las lneas que estn 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 ningn esfuerzo explcito para sicronizar los threads, el Consumidor consume con un abandono temerario y obtiene slo una ristra de ceros, en lugar de obtener los enteros entre 0 y 9 exactamente una vez cada uno.

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
ARTÍCULO ANTERIOR

SIGUIENTE ARTÍCULO

HAY 1 COMENTARIOS
  • Anónimo dijo:

    Hola muy buena la explicaion sobre threads, pero tuvieras algun ejemplo pero aplicado a action sript 2 o php

Conéctate o Regístrate para dejar tu comentario.