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

Curso JAVA
Unidad 5: "Threads y multitarea"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

Lima - Per�, 2002

Hosted by www.Geocities.ws