codexpress

La Clase Thread

La forma más directa para hacer un programa multi-thread es extender la clase Thread y redefinir el método run(). Este método es invocado cuando se inicia el thread (mediante una llamada al método start() de la clase thread). El thread se inicia con la llamada al método run y termina cuando termina éste.

Ejemplo:

public class ThreadExample extends Thread {
public ThreadExample(String str) {
super(str);
}

public void run() {
for (int i = 0; i < 10 ; i++)
System.out.println(i + ” ” + getName());
System.out.println(”Termina thread ” + getName());
}

public static void main (String [] args) {
new ThreadExample(”Nombre 1″).start();
new ThreadExample(”Nombre 2″).start();
System.out.println(”Termina thread main”);
}
}

Ejecuta varias veces el programa y verás que no siempre se ejecuta igual.
Notas sobre el programa:

• La clase Thread está en el package java.lang. Por tanto no es necesario el import.
• El constructor public Thread(String str) recibie un parámetro que es la identificación del Thread.
• El método run contiene el bloque de ejecución del Thread. Dentro de él, el método getName() devuelve el nombre del Thread (el que se ha pasado como argumento al constructor).
• El método main crea dos objetos de clase ThreadEjemplo y los inicia con la llamada al método start(). (el cual inicia el nuevo thread y llama al método run() ).
• Observa en la salida el primer mensaje, de finalización del thread main. La ejecución de los threads es asíncrona. Realiza la llamada al método start(), éste le devuelve control y continua su ejecución, independiente de los otros threads.
• En la salida los mensajes de un thread y otro se van mezclando. La máquina virtual asigna tiempos a cada thread.

Otro ejemplo:

public class TestThreadHello extends Thread {
private String name;
private int delay;

// Constructor para almacenar nuestro nombre
// y el retardo
public TestThreadHello(String s, int d) {
name = s;
delay = d;
}

// El metodo run() es similar al main(), pero para
// threads. Cuando run() termina el thread muere
public void run() {
// Retasamos la ejecución el tiempo especificado
try {
sleep(delay);
} catch (InterruptedException e) {
;
}

// Ahora imprimimos el nombre
System.out.println(”Hola Mundo! ” + name + ” ” + delay);
}
}

La Interface Runnable

La interface Runnable proporciona un método alternativo a la utilización de la clase Thread, para los casos en los que no es posible hacer que nuestra clase extienda la clase Thread. Esto ocurre cuando la clase que deseamos correr en un thread independiente deba extender alguna otra clase. Dado que no existe herencia múltiple, nuestra clase no puede extender a la vez la clase Thread y otra más. En este caso nuestra clase debe implantar la interface Runnable, variando ligeramente la forma en que se crean e inician los nuevos threads.

El siguiente ejemplo es equivalente al del apartado anterior, pero utilizando la interface Runnable:

public class ThreadEjemplo implements Runnable {
public void run() {
for (int i = 0; i < 5 ; i++)
System.out.println(i + ” ” + Thread.currentThread().getName());
System.out.println(”Termina thread ” + Thread.currentThread().getName());
}
public static void main (String [] args) {
new Thread ( new ThreadEjemplo() , “Pepe”).start();
new Thread ( new ThreadEjemplo() , “Juan”).start();
System.out.println(”Termina thread main”);
}
}

Observese en este caso:

• Se implanta la interface Runnable en lugar de extender la clase Thread.
• El constructor que había antes no es necesario.
• En el main observa la forma en que se crea el thread. Esa expresión es equivalente a:

ThreadEjemplo ejemplo = new ThreadEjemplo();
Thread thread = new Thread ( ejemplo , “Pepe”) ;
thread.start();

1. Primero se crea la instancia de nuestra clase.
2. Después se crea una instancia de la clase Thread, pasando como parámetros la referencia de nuestro objeto y el nombre del nuevo thread.
3. Por último se llama al método start de la clase thread. Este método iniciará el nuevo thread y llamará al método run() de nuestra clase.

• Por útlimo, obsérvese la llamada al método getName() desde run(). getName es un método de la clase Thread, por lo que nuestra clase debe obtener una referencia al thread propio. Es lo que hace el método estático currentThread() de la clase Thread.

Referencia:

Threads
Hilos y Multihilos