TALLER HILOS

DEFINICION DE UN HILO

Un hilo es una secuencia de código en ejecución dentro del contexto de un proceso.  Los hilos requieren la supervisión  de un proceso padre para correr. Los hilos además son conocidos como un proceso ligero, es muy similar a un proceso a diferencia que este corre siempre corre dentro del contexto de otro programa. Comúnmente, los hilos son implementados a nivel de sistema, requiriendo una interfaz de programación específica separada del núcleo de lenguaje de programación  

CICLO DE VIDA DE UN HILO

Un hilo puede pasar por varios estados durante su vida (CREACION, EJECUCION, PAUSA o TERMINACION)

Recién creada (New thread): entra aquí inmediatamente despues de su creación. Es decir luego del llamado a new. En este estado los datos locales son ubicados e iniciados. Luego de la invocación a start(), el hilo pasa al estado "corrible".

Corrible (Runnable): Aquí el contexto de ejecución existe y el hilo puede ocupar la CPU en cualquier momento. Este estado puede subdividirse en dos: Corriendo y encolado. La transición entre estos dos estados es manejado por lel itinerador de la máquina virtual.

Nota: Un hilo que invoca al método () voluntariamente se mueve asimisma al estado encolado desde el estado corriendo.

Bloqueada (not Runnable): Se ingresa cuando: se invoca suspend(), el hilo invoca el método wait() de algún objeto, el hilo invoca sleep(), el hilo espera por alguna operación de I/O, o el hilo invoca join() de otro hilo para espera por su término. El hilo vuelve al estado Corrible cuando el evento por que espera ocurre.

Muerta (Dead): Se llega a este estado cuando el hilo termia su ejecución (concluye el método run) o es detenida por otro hilo llamando al su método stop(). Esta última acción no es recomendada.

La prioridad de un hilo tiene el efecto de:

1. Si hay 2 hilos para ejecutarse, se ejecuta primero el de mayor prioridad.
2. Si hay 1 hilo ejecutándose y entra un hilo de mayor prioridad, el primer hilo sale de ejecución y entra este ultimo.

Hilos demonio: Son hilos de muy baja prioridad (llamados servicios) que normalmente se ejecutan en periodos muy largos usando pocos recurso. Para crear un demonio se usa setDaemon(): true o false.

SINTAXIS DE CREACION DE UN HILO

Hay dos modos de conseguir threads en Java. Una es implementando la interface Runnable, la otra es extender la clase Thread.

La implementación de la interface Runnable es la forma habitual de crear threads. Las interfaces proporcionan al programador una forma de agrupar el trabajo de infraestructura de una clase. Se utilizan para diseñar los requerimientos comunes al conjunto de clases a implementar. La interface define el trabajo y la clase, o clases, que implementan la interface realizan ese trabajo. Los diferentes grupos de clases que implementen la interface tendrán que seguir las mismas reglas de funcionamiento.

Hay una cuantas diferencias entre interface y clase. Primero, una interface solamente puede contener métodos abstractos y/o variables estáticas y finales (constantes). Las clases, por otro lado, pueden implementar métodos y contener variables que no sean constantes. Segundo, una interface no puede implementar cualquier método. Una clase que implemente una interface debe implementar todos los métodos definidos en esa interface. Una interface tiene la posibilidad de poder extenderse de otras interfaces y, al contrario que las clases, puede extenderse de múltiples interfaces. Además, una interface no puede ser instanciada con el operador new; por ejemplo, la siguiente sentencia no está permitida:

Runnable a = new Runnable();   // No se permite

El primer método de crear un thread es simplemente extender la clase Thread:

class MiThread extends Thread {

    public void run() {

        . . .

        }

El ejemplo anterior crea una nueva clase MiThread que extiende la clase Thread y sobrecarga el método Thread.run() por su propia implementación. El método run() es donde se realizará todo el trabajo de la clase. Extendiendo la clase Thread, se pueden heredar los métodos y variables de la clase padre. En este caso, solamente se puede extender o derivar una vez de la clase padre. Esta limitación de Java puede ser superada a través de la implementación de Runnable:

public class MiThread implements Runnable {

    Thread t;

    public void run() {

        // Ejecución del thread una vez creado

        }

    }

En este caso necesitamos crear una instancia de Thread antes de que el sistema pueda ejecutar el proceso como un thread. Además, el método abstracto run() está definido en la interface Runnable tiene que ser implementado. La única diferencia entre los dos métodos es que este último es mucho más flexible. En el ejemplo anterior, todavía tenemos oportunidad de extender la clase MiThread, si fuese necesario. La mayoría de las clases creadas que necesiten ejecutarse como un thread , implementarán la interface Runnable, ya que probablemente extenderán alguna de su funcionalidad a otras clases.

No pensar que la interface Runnable está haciendo alguna cosa cuando la tarea se está ejecutando. Solamente contiene métodos abstractos, con lo cual es una clase para dar idea sobre el diseño de la clase Thread. De hecho, si vemos los fuentes de Java, podremos comprobar que solamente contiene un método abstracto:

package java.lang;

public interface Runnable {

    public abstract void run() ;

}

Y esto es todo lo que hay sobre la interface Runnable. Como se ve, una interface sólo proporciona un diseño para las clases que vayan a ser implementadas. En el caso de Runnable, fuerza a la definición del método run(), por lo tanto, la mayor parte del trabajo se hace en la clase Thread. Un vistazo un poco más profundo a la definición de la clase Thread nos da idea de lo que realmente está pasando:

public class Thread implements Runnable {

    ...

    public void run() {

        if( tarea != null )

            tarea.run() ;

            }

        }

    ...

    }

CLASE Y METODOS DE UN HILO

Clase Thread: Maneja hilos de ejecución. Hay metodos que controlan si el hilo esta ejecutado, durmiendo, en suspenso o detenido.

Metodos básicos:
1. sleep(milis): Pone en suspenso un hilo en ejecución durante un cierto tiempo.
2. start(): Pone a ejecutar un hilo. Crea un hilo de sistema y ejecuta. Luego llama al metodo run().
3. run(): Lleva el cuerpo del hilo. Es llamado por el metodo start(). Normalmente es un bucle. Hay que redefinirlo.
4. suspend(): Detiene el hilo, pero no lo destruye. Puede ejecutarse de nuevo. Met.de instancia.
5. resume(): Reanuda el hilo de ejecución detenido. Met.de instancia.
6. interrupt(): Detiene el hilo de ejecución, normalmente no se usa, se deja que el hilo termine su correcta ejecución.
7. join(): Fuerza al hilo a esperar la finalizacion de los hilos asociados.

INTERFACE RUNNABLE

Al implementar la interfaz Runnable en una clase, un objeto puede manipular objetos de esa clase como objetos Runnable. Y tal como cuando heredamos de Thread, debemos declarar y sobrecargar el método run().

Cuando una clase utiliza un objeto Runnable para manipular subprocesos, este crea un objeto Thread y asocia el objeto Runnable con ese objeto Thread (¿enredado? para nada; sigue leyendo y verás que es muy sencillo). La clase Thread posee constructores que pueden recibir objetos Runnable, por ejemplo el constructor

public Thread(Runnable objetoRunnable)

especifica que el método run() del objeto objetoRunnable es el que debe invocarse cuando el subproceso comience a ejecutarse. Por otro lado, el construtor

public Thread(Runnable objetoRunnable, String nombreHilo)

crea un objeto Thread con el nombre nombreHilo, y especifica que el método run() del objeto objetoRunnable es el que debe invocarse cuando el subproceso comience a ejecutarse. ¡Veamos un ejemplo para entender mejor!

BIBLIOGRAFIA

http://www.arcos.inf.uc3m.es/~pstr/transparencias/concurren.pdf

http://sunsite.dcc.uchile.cl/java/docs/JavaTut/Cap7/creath.html

http://www.sc.ehu.es/sbweb/fisica/cursoJava/applets/threads/runnable.htm