(c)BIT - Ud.5 Curso Java: unidades didacticas

	Curso JAVA Unidad 5: "Threads y multitarea"
	www.bit.es - Calendario de cursos - Solicitud de información

Curso Java
Curso Analista Programador entorno Java

Objetivos de la Unidad:

Comparación entre la programación monoThread y programación multiThread.
Creación de threads por herencia de la clase Thread
Creación de threads por implementación del interface Runnable
Comparación entre ambos sistemas y utilización práctica.
Prioridades de los threads
Secciones críticas en Java. La sentencia synchronized
El modelo productor-consumidor.

1.- Programación modular clásica

El mecanismo de llamada a una función o subrutina puede descomponerse en 3 etapas:
1) Antes de saltar a la dirección de memoria donde se encuentra la función o subrutina a ejecutar se dejan en la pila la dirección desde donde se efectúa la llamada (punto de retorno) y los parámetros de la misma.
2) Lo primero hace la subrutina es recoger los parámetros de la pila y copiarlos en los parámetros formales (que son como variables locales) y se empieza la ejecución del código.
3) Al acabar (por ejemplo al encontrar un return) se obtiene la dirección de retorno (que también pasa por la pila), se deposita el valor del return en la pila y se ejecuta la instrucción inmediatamente después de la dirección de retorno.
Con este modelo no se pueden lanzar ejecuciones paralelas de código.

2.- Programación con Threads ("Hilos")

La noción de proceso o tarea a nivel de sistema operativo implica un contexto de ejecución propio por lo que su creación y destrucción así como la compartición de memoria puede ser pesada y no directa.
Un Thread es un proceso ligero, es decir, no tiene contexto propio sino que utiliza el mismo del proceso padre.
Un Thread puede ser del tipo "daemon" lo que significa que si muere el proceso padre, automáticamente él también.
La filosofía es iniciar la ejecución de código y a diferencia de la programación modular clásica, no esperar al retorno para continuar la ejecución del programa.
De este modo, cuando se inicia un Thread se establecen dos tareas en paralelo: la creadora y la creada.
Cuando se ejecuta un Thread se llama al método run() el cual hace las veces de main() del Thread
Cuando un programa se inicia en main se ejecuta el Thread mainThread
Java soporta los Threads a nivel de lenguaje y por debajo utiliza la multitarea del sistema operativo que se esté ejecutando.
El problema principal que aparece con la programación multithread es la sincronización de tareas. ¿Qué ocurre si dos Threads modifican simultáneamente una variable común?

3.- Conversión de una llamada a función normal a una multithread

Supongamos que disponemos de una función denominada servicio tal como:

void servicio(String s, int a, boolean b)
{
<código de servicio>
}

Una llamada a la función servicio sería:

...
servicio("Hola", 5, true);
...

En este caso la línea siguiente a la llamada no se ejecutará hasta que servicio devuelva el control.

En programación multithread podríamos escribir lo siguiente:

...
new Servicio("Hola", 5, true);
...

En este caso la línea siguiente a la llamada se ejecutará independientemente (en paralelo) con el thread de Servicio.

La técnica para pasar de la primera forma a la segunda consiste en mapear el constructor de Thread con los mismos parámetros, de modo que la clase Servicio quedaría como sigue:

class Servicio extends Thread
{
    String s;
    int a;
    boolean b;

    Servicio(String s, int a, boolean b)
    {
        this.s = s;
        this.a = a;
        this.b = b;
        start();     // el Thread se autoarranca
    }

    public void run()
    {
        try
        {
            <código de servicio>
        }
        catch(InterruptedException e) {}
    }
}

Obsérvese que run accedería a las variables miembro directamente de modo equivalente que la función servicio en que estos datos llegan como parámetros.

El método start es al comando java (ó jview) lo que run es a main

La llamada a una función en modo clásico se puede ver como un caso de particular en el modelo multithreaded. Basta con indicar que el Thread del programa "llamante" se bloquee hasta que el "llamdado" no termine. Ello se consigue utilizando el método join:

...
new Servicio("Hola", 5, true).join();
...

El método join es utilizado en aquellos casos en que se lanzan varios threads y no se quiere continuar hasta que acaben todos ellos:

    Thread t1 = new ...
    Thread t2 = new ...
    Thread t3 = new ...

    t1.join();
    t2.join();
    t3.join();

En este caso hasta que no terminen los tres Threads t1, t2 y t3 el programa no pasará la zona de joins. En cierto modo actúa como un elemento transaccional (se componen en lógica "AND").

4.- Herencia de Thread versus implementación de Runnable

El primer método es el más intuitivo conceptualmente, pero tiene el inconveniente de que al utilizar la herencia la clase ya no puede derivar de ninguna otra clase.
En la práctica se utiliza casi exclusivamente la implementación de Runnable. El diseño de esta interface y su utilización son un ejemplo de como utilizar herencia múltiple.
Veremos a continuación el clásico ejemplo de threads PingPong comparando los dos sistemas y mostrando que el sobreesfuerzo práctico (que no conceptual) en la utilización de Runnable es mínimo.

//
// EjemploThread.java
//
class EjemploThread
{
public static void main(String args[])
{
// Utilizando herencia de Thread
PingPong t1= new PingPong(1000,"Ping");
PingPong t2= new PingPong(3000,"Pong");
t1.start();
t2.start();
// Implementando Runnable
PingPongr t1r= new PingPongr(1000,"Pingr");
PingPongr t2r= new PingPongr(3000,"Pongr");
t1r.t.start();
t2r.t.start();
}
}

//
// PingPong.java
//
class PingPong extends Thread
{
int interval;
String text;
PingPong(int interval0, String text0)
{
interval = interval0;
text = text0;
}
public void run()
{
try
{
   for(;;)
   {
    System.out.println(text);
    sleep(interval);
   }
}
catch ( InterruptedException e )
{
   return;
}
}
}
//
// PingPongr.java
//
class PingPongr implements Runnable
{
// Hay que crear el Thread
Thread t;
int Interval;
String text;
PingPongr(int Interval0,String text0)
{
   // Aqui asociamos el Thread al Objeto
   t=new Thread(this);
   Interval = Interval0;
   text=text0;
}
public void run()
{
   try
   {
    for(;;)
    {
     System.out.println(text);
     // El thread es t no la propia clase
     t.sleep(Interval);
    }
   }
   catch ( InterruptedException e)
   {
    return;
   }
}
}

5.- Ciclo de vida de un Thread.

Los Threads siguen el siguiente diagrama de estados:

Quantum es la cuota de tiempo en que un Thread está en la CPU. Los Threads se intercambian entre sí mediante un algoritmo circular ("round-robin")
La operación de dispatch consiste en seleccionar un proceso para que sea él el que entre en ejecución.
suspend y resume son metodos de Thread.
Cuando se realiza una petición de operación de I/O el Thread queda bloqueado hasta que termine la operación.
El mecanismo de wait, notify y notifyAll se utiliza para coordinar el sincronismo cuando varios Threads intentan acceder simultáneamente a un recurso (objeto) común.
El thread en ejecución incluso el correspondiente al programa principal (main) se puede obtener con el método estático currentThread() de la clase Thread.
Con ello se podría detener la ejecución del hilo un tiempo determinado:

            ...
      Thread.currentThread().sleep(2000); // el programa se detiene durante 2 segundos
      ...

6. Sincronización

Supongamos el siguiente esquema:

Los métodos get y put acceden a una variable interna i que indica la producción hasta el momento.
La idea es que cuando p realiza un put(),hasta que c no haya realizado un get() p debe esperarse a realizar otro put(). Lo mismo para viceversa.
Para lograr la sincronización los métodos get y put deben ser del tipo syncronized.
Cuando se accede a un método syncronized cualquier llamada desde cualquier objeto quedará en espera hasta que el Thread salga de dicho método syncronized.
Java asocia a cada objeto un Monitor el cual actúa de cerrojo.
Un objeto se convierte en propietario del monitor de otro cuando el primero ejecuta un método o bloque de código del segundo.
Para coordinar los accesos al recurso común se dispone de los métodos wait, notify y notifyAll. El primero deja a un Thread en estado waiting y le quita la propiedad sobre el objeto monitor que poseía. Los métodos notify indican que entre el siguiente Thread (el que le toque)

7.- Ejemplo

//
// PC.java
//
// Problema del productor-consumidor
//

/// Recurso accedido por p y c

class Q
{
int n;
boolean valueSet = false;

    synchronized int get()
    {
        if (!valueSet)
            try {wait();} catch (InterruptedException e){}

        System.out.println("Obtenido: " + n);
        valueSet = false;
        notify();
        return n;
    }

    synchronized void put(int n)
    {
        if (valueSet)
            try {wait();} catch (InterruptedException e){}

        this.n = n;
        valueSet = true;
        System.out.println("Colocado: " + n); notify();
    }
}

Productor implements Runnable
{
Q q;
Thread t;

    Productor(Q q)
    {
        this.q = q; t = new Thread(this, "Productor");
        t.start();
    }

    public void run()
    {
        int i = 0;
        while(true)
        {
            try {t.sleep(1500);} catch(Exception e){}
            q.put(i++);
        }
    }
}

Consumidor implements Runnable
{
Q q;
Thread t;

    Consumidor(Q q)
        {
        this.q = q; t = new Thread(this, "Consumidor");
        t.start();
    }

    public void run()
    {
        while(true)
        {
            try {t.sleep(1000);} catch(Exception e){}
            q.get();
        }
     }
}

PC
{
    public static void main(String args[])
        {
        Q q = new Q();
        new Productor(q);
        new Consumidor(q);
    }
}

8.- Miscelánea

Los Threads pueden ser del tipo daemon.
Un daemon muere si el proceso padre que lo creó también muere.
Un Thread pasa a daemon mediante el métodosetDaemon().
Els Threads pueden tener hasta 10 niveles de prioridat. Se fija con setPriority()
Los Threads pueden agruparse en objetos del tipo GroupThread. Es útil cuando se quieren cambiar condiciones en grupo (prioridades, etc.)

Unidad anterior - Unidad siguiente