Hilos en Java(Threads) parte 3

Recordemos lo visto en la segunda parte de Hilos en Java:

- Existen diversos tipos de constructores a partir de los cuales se puede crear un hilo, algunos de los más importantes son:
+ Thread()
+ Thread(objetoRunnable)
+ Thread(objetoRunnable, String nombre)
+ Thread(String nombre)

- Un hilo recién creado e instanciado se encuentra en estado nuevo (new), pasa a estado en ejecución (runnable) cuando se llama a su método start() y se considera muerto (dead) una vez que se completa lo contenido en su método run().

- Para llamar al método start() se necesita una instancia de la clase Thread.

- El método estático Thread.currentThread().getName() se utiliza para saber qué proceso se encuentra en ejecución en un momento determinado.

- Cuando se trata de hilos, muy pocas cosas está garantizadas. Una de ellas es que cada hilo se iniciará y se ejecutará hasta que se complete pero no en un orden específico ni sin interrupciones.

- Solamente se puede llamar una vez al método start() de un hilo en particular, de lo contrario se obtiene una excepción de tipo java.lang.IllegalThreadStateException.

Sigamos pues con los hilos en Java.

Más info tras el salto...




El programador de hilos::

En la máquina virtual de Java existe algo que llamamos el programador de hilos que es el encargado de decidir qué hilo es el que se va a ejecutar por el procesador en un momento determinado y cuándo es que debe de parar o pausar su ejecución. Asumiendo que se tiene un equipo de un solo procesador, solo un proceso puede estar corriendo en un momento dado, como lo hemos mencionado anteriormente, la idea de multi-proceso o multithreading es meramente aparente. Para que un hilo sea elegible para ser ejecutado, este debe de estar en estado en ejecución (runnable), si se encuentra en cualquier otro estado no podrá ser elegible por el programador de hilos. Es importante tomar en cuenta que...

"El orden en que un hilo en estado de ejecución es escogido por el programador de hilos no es garantizado".

...aunque no podemos controlar al programador de hilos, en algunas ocasiones podemos influenciarlo mandando a llamar algunos métodos contenidos en la clase java.lang.Thread.

Los métodos de la clase java.lang.Thread::

Algunos métodos de esta clase nos pueden ayudar a influenciar al programador de hilos a tomar una decisión sobre qué hilo ejecutar en qué momento. Los métodos son los siguientes:

+ public static void sleep(long milisegundos) throws InterruptedException
+ public static void yield()
+ public final void join() throws InterruptedException
+ public final void setPriority(int nuevaPrioridad)

Nota: el método sleep() y join() tienen versiones sobrecargadas que no hemos mencionado.

Algunos métodos de la clase java.lang.Object::

Recordemos que toda clase en Java hereda de la clase Object, por lo tanto, cualquier objeto de cualquier tipo tiene todos los métodos de la clase Object por defecto. En este caso analizaremos algunos de ellos que nos son útiles en el manejo de hilos:

+ public final void wait() throws InterruptedException
+ public final void notify()
+ public final void notifyAll()

El método wait() define 3 versiones sobrecargadas, incluyendo la mencionada anteriormente.

Antes de mencionar el comportamiento de los métodos anteriormente mencionados, analicemos algunos estados más en los que un hilo se puede encontrar y sus respectivas transiciones.

Estados de los hilos y transiciones::

Ya hemos visto 3 estados de los hilos - nuevo, en ejecución y muerto - pero hay algunos otros bastante importantes. Analicemos cada uno de ellos:

- Nuevo (new): Este es el estado en que un hilo se encuentra después de que un objeto de la clase Thread ha sido instanciado pero antes de que el método start() sea llamado.

- En ejecución (runnable): Este es el estado en que un hilo puede ser elegido para ser ejecutado por el programador de hilos pero aún no está corriendo en el procesador. Se obtiene este estado inmediatamente después de hacer la llamada al método start() de una instancia de la clase Thread.

- Ejecutándose (running): Este es el estado en el que el hilo está realizando lo que debe de hacer, es decir, está realizando el trabajo para el cual fue diseñado.

- Esperando/bloqueado/dormido (waiting/blocked/sleeping): Es el estado en el cual el hilo está vivo aún pero no es elegible para ser ejecutado,es decir, no está en ejecución pero puede estarlo nuevamente si algún evento en particular sucede. Por ejemplo, un hilo puede estar durmiendo por que en el código se le ha pedido que lo haga pero pasa a estado en ejecución cuando el tiempo que se le pidió dormir ha expirado.

- Muerto (dead): Un hilo está muerto cuando se han completado todos los procesos y operaciones contenidos en el método run(). Una vez que un hilo ha muerto NO puede volver nunca a estar vivo, recordemos que no es posible llamar al método start() más de una vez para un solo hilo.

Prevenir la ejecución de un hilo::

:Hilo Durmiendo (sleeping):

El método sleep() es un método estático de la clase Thread. Generalmente lo usamos en el código para pausar un poco la ejecución de un proceso en particular forzándolo a dormir durante un tiempo determinado. Para forzar un hilo a dormir podemos usar un código parecido a lo siguiente:

try{
Thread.sleep(5*60*1000); //Duerme durante 5 minutos
}catch(InterruptedException ex){}

Normalmente cuando llamamos al método sleep() encerramos el código en un try/catch debido a que dicho método arroja una excepción.

El hecho de que un hilo deje de dormir, no significa que volverá a estar ejecutándose al momento de despertar, el tiempo especificado dentro del método sleep() es el mínimo de tiempo que un hilo debe de dormir, aunque puede ser mayor. De igual manera se debe de tomar en cuenta que el método sleep() es estático, es decir, solo hay uno para toda la clase Thread, por lo tanto, un hilo no puede poner a dormir a otro, el método sleep() siempre SIEMPRE afecta al hilo que se encuentra ejecutando al momento de hacer la llamada.

:Prioridades de hilo y el método yield():

Para entender el método yield(), debemos entender las prioridades de los hilos. Un hilo siempre corre con una prioridad, normalmente va de 1 a 10, debido a esto, el programador de hilos generalmente utiliza su programación basada en prioridades. Un hilo de menor prioridad que se encuentra ejecutando usualmente será desplazado al estado en ejecución para que un hilo de mayor prioridad pueda ejecutarse. De cualquier manera, nunca debes de basar el funcionamiento de tu aplicación basado en las prioridades de los hilos.

Para establecer la prioridad de un hilo debemos hacer algo parecido a lo siguiente:

HiloRunnable h = new HiloRunnable();
Thread t = new Thread(h);
t.setPriority(7);
t.start();

Algunas máquinas virtuales no son capaces de reconocer 10 valores diferentes de prioridad, lo que causa un problema al momento de la ejecución, debido a ello, la clase Thread tiene 3 constantes (variables estáticas y finales) que definen un rango de prioridades de hilo:

+ Thread.MIN_PRIORITY (1)
+ Thread.NORM_PRIORITY (5)
+ Thread.MAX_PRIORITY (10)

:El método yield():

El método yield() tiene la función de hacer que un hilo que se está ejecutando de regreso al estado en ejecución(runnable) para permitir que otros hilos de la misma prioridad puedan ejecutarse. Sin embargo, el funcionamiento de este método (al igual que de los hilos en general) no está garantizado, puede que después de que se establezca un hilo por medio del método yield() a su estado en ejecución(runnable), éste vuelva a ser elegido para ejecutarse. El método yield() nunca causará que un hilo pase a estado de espera/bloqueado/dormido, simplemente pasa de ejecutándose(running) a en ejecución(runnable).

:El método join():

El método no estático join() permite al hilo "formarse en la cola de espera" de otro hilo. Si tienes un hilo B que no puede comenzar a ejecutarse hasta que se complete el proceso del hilo A, entonces querrás que B se forme en la cola de espera de A. Esto significa que B nunca podrá ejecutarse si A no completa su proceso. En código se utiliza así:

Thread t = new Thread();
t.start();
t.join();

Existe una versión sobrecargada de join() que puede incluir el tiempo en milisegundos, por ejemplo si llamamos a t.join(5000), significa que el hilo que queremos ejecutar debe esperar a que el hilo que se está ejecutando en este momento termine, pero si tarda más de 5 segundos entonces debe dejar de esperar y entrar en estado de ejecución(runnable).

Hasta aquí le dejamos con la tercera parte...

Más sobre programación en Java aquí.