Ejemplo de hilos 1.

view source

print?

001.package es.scjp;

002. 

003. 

004./**

005. * Esta clase muestra los conceptos básicos de los hilos en Java Recordamos los

006. * siguientes conceptos básicos: 1) Un hilo puede ser definido por la

007. * implementación de la interfaz runnable y la implementación de su método run,

008. * o bien por la extensión de una clase thread. 2) Un hilo tiene diferentes

009. * estados durante su ciclo de vida, estos son los siguientes: new, runnable,

010. * running y dead. 3) Un hilo necesita ser instanciado, y sólo puede ser

011. * ejecutado una sola vez, con el método start. Si se intenta ejecutar de nuevo

012. * dará una excepción de tipo RunTimeException

013. *

014. * @author jcarmonaloeches

015. * @desarrolloj2ee (twitter)

016. *

017. */

018.public class HilosEnJavaParte1 {

019. 

020.    public static void main(String args[]) {

021.        Hilo1 hilo1 = new Hilo1();

022.        Thread hilo1Thread = new Thread(hilo1);

023.        System.out.println("Estado del hilo1 después de la creación "

024.                + hilo1Thread.getState());

025.        hilo1Thread.start();

026.        System.out.println("Estado del hilo1 después de la ejecución "

027.                + hilo1Thread.getState());

028.        /**

029.         * Detenemos la variable esta corriendo para finalizar el método run e

030.         * introducimos una pausa de 5 segundos

031.         */

032.        try {

033.            Thread.sleep(5000);

034.        } catch (InterruptedException e) {

035.            // TODO Auto-generated catch block

036.            e.printStackTrace();

037.        }

038.        System.out

039.                .println("Estado del hilo1 después de finalizar el método run "

040.                        + hilo1Thread.getState());

041. 

042.        Hilo2 hilo2 = new Hilo2();

043.        System.out.println("Estado del hilo2 después de la creación");

044.        hilo2.start();

045.        System.out.println("Estado del hilo2 después de la ejecución");

046.        /**

047.         * Detenemos la variable esta corriendo para finalizar el método run e

048.         * introducimos una pausa de 5 segundos

049.         */

050.        try {

051.            Thread.sleep(5000);

052.        } catch (InterruptedException e) {

053.            // TODO Auto-generated catch block

054.            e.printStackTrace();

055.        }

056.        System.out

057.                .println("Estado del hilo2 después de finalizar el método run "

058.                        + hilo1Thread.getState());

059.        /**

060.         * Intentamos invocar de nuevo al hilo: aquí sabemos que puede lanzarse

061.         * una excepción en tiempo de ejecución, y por lo tanto no debe ser

062.         * capturada

063.         */

064.        System.out

065.                .println("Intentamos ejecutar un hilo que quedó parado de nuevo");

066.        hilo2.start();

067. 

068.    }

069.}

070. 

071./**

072. * Los hilos pueden generarse de varias maneras. Una de ellas es implementando

073. * el método runnable

074. *

075. * @author jaime

076. *

077. */

078.class Hilo1 implements Runnable {

079. 

080.    /**

081.     * Runnable nos obliga a redifinir el método run Este método imprime cada

082.     * tres segundos el nombre del hilo mientras la variable estaCorriendo así

083.     * lo indique

084.     */

085.    public void run() {

086.        try {

087.            Thread.sleep(500);

088.            System.out.println("EJECUTANDO...."

089.                    + Thread.currentThread().getName());

090.        } catch (InterruptedException e) {

091.            // TODO Auto-generated catch block

092.            e.printStackTrace();

093.        }

094.    }

095.}

096. 

097./**

098. * Otra opción es extendiendo de Thread y sobreescribiendo el método run

099. *

100. * @author jaime

101. *

102. */

103.class Hilo2 extends Thread {

104. 

105.    public void run() {

106.        try {

107.            Thread.sleep(500);

108.            System.out.println("EJECUTANDO...."

109.                    + Thread.currentThread().getName());

110.        } catch (InterruptedException e) {

111.            // TODO Auto-generated catch block

112.            e.printStackTrace();

113.        }

114.    }

115.}

En el ejemplo anterior hemos visto qué existen en Java dos posibilidades de definición de un hilo, bien implementado la interfaz runnable, bien extendiendo de Thread. En ambos casos, es necesario redefinir (en el caso de extender de Thread) o implementar (en el caso de implementar la interfaz Runnable) el método run. Dicho método nos permite realizar una ejecución de un hilo.

Los pasos a seguir para la creación de un hilo son los siguientes:

1. Definimos una clase que implemente Runnable o extienda de Thread.
2. Redefinimos o implementamos el método start.
3. Más tarde, desde una clase principal, creamos una instancia del hilo.
4. Para ejecutar la instancia del hilo llamamos a la ejecución de start.
5. Si existen varios hilos en ejecución, la JVM se encargará de alternar dicha ejecución. Es bueno conocer que se pueden asignar prioridades de ejecución a los hilos, que van desde el 1 hasta el 10. Sin embargo, la asignación de estas prioridades no nos garantiza un orden de ejecución, por lo que es bueno conocer que no podemos asegurar la salida de un programa escrito en Java donde dos hilos compartan la ejecución. Es decir, la salida es NO PREVISIBLE en todos los casos (aunque a nivel práctico en ocasiones se pueda preveer la salida).

Comments

[ju4n]

Muy bien explicado...muchas gracias!!!