Cómo implementar un Thread (Hilo) en Java

Considero que los Thread es una de las características más importantes de Java, ya que contribuyó a que éste se convirtiera en un lenguaje de programación mucho más popular, pues una de las habilidades que se busca un programador es su comprensión sobre programación multi-hilos, y su capacidad para escribir aplicaciones que realicen sub-procesos múltiples.

El principal problema con la programación de aplicaciones que puedan ejecutar varios sub-procesos al mismo tiempo, está relacionado con inconvenientes relacionados con concurrencia, deadlock, race condition, entre otros, lo cual lleva a que implementar multi-hilos en algunas aplicaciones Java requiera de cierto esfuerzo.

En este tutorial veremos algunas formas de implementar un Thread (hilo) en Java, lo cual le permitirá crear e inicializar hilos ya sea implementando la interface Runnable o extendiendo de la clase Thread.

Cómo crear un Thread en Java

Existen dos formas de implementar hilos en Java:

1) Extendiendo de la clase java.lang.Thread

2) Implementando la interface java.lang.Runnable

Antes de entrar en detalles sobre cómo implementar una opción o la otra, sería pertinente saber cuando debemos usar un Thread en Java. Un hilo o thread en Java lo usaremos en caso de que queramos que una funcionalidad (parte del código) de nuestro programa se ejecute en paralelo al proceso principal, así pues, dicho código lo colocaríamos dentro del método run() de la clase Thread o la interface Runnable para que se cumpla dicho cometido.

Como tal, el método público run() se define en la interface Runnable, y como la clase Thread implementa dicha interface, hereda automáticamente éste método.

Teniendo en cuenta de que contamos con dos formas de implementar un Thread en Java, una pregunta que tal vez puede surgirnos es saber cuál de las dos es mejor: extendiendo de la clase Thread o implementando la interface Runnable.

Por cuestiones de diseño, considero que la mejor forma es implementando la interface Runnable, ya que si tenemos en cuenta de que en Java sólo podemos extender de una sola clase, si extendemos de la clase Thread, ya no podríamos hacerlo de alguna otra clase, mientras que implementando la interface Runnable, podremos implementar otra interface en cualquier momento que necesitemos.

Además, tengamos en cuenta que según la Programación Orientada a Objetos, el propósito de extender una clase es proporcionar alguna característica o funcionalidad nueva, así que si nuestro propósito es simplemente usar el método run(), el cual usaremos solamente para definir qué parte de nuestro código se ejecutará en otro hilo, la opción más razonable sería implementar la interface Runnable.

Así que después de decidir de qué forma se creará el Thread en java, lo siguiente que debemos hacer es crear el objeto de nuestro thread e iniciar el sub-proceso. Esto creará una ruta de ejecución separada paralela al hilo principal de la aplicación.

Cómo se ejecuta un Thread en Java

Un thread en java está basado en estados, así que cuando se crea un objeto de la clase del thread que definimos extendiendo de la clase Thread o implementando de la interface Runnable, éste solamente se crea con un estado predefinido, pero no se iniciará hasta que se llame al método start() de la clase java.lang.Thread.

Entonces, cuando creamos el objeto del thread en java, éste quedará en un estado New, y al llamar al método start(), la Máquina Virtual de Java ejecuta el método run() de la clase que definimos, lo que hace que el thread pase al estado Runnable. A partir de aquí, sera el planificador de Threads el encargado de asignar CPU a este sub-proceso (hilo).

Ya después de esto, el thread puede pasar a estado Terminated o quedar en estado Waiting, Time Waiting o Blocked. Veamos el código:

Ejemplo de implementación de un Thread en Java

// Implementación de hilos extendiendo de la clase Thread
public class MyThread extends Thread {

    public void run() {
        System.out.println("Thread Running " + Thread.currentThread().getName());
    }

}


// Implementación de hilos implementando la interface Runnable
public class MyRunnable implements Runnable {         

    public void run() {
        System.out.println("Creamos Thread " + Thread.currentThread().getName());
    }

}


// Iniciando Threads en Java
Thread mythread = new MyThread(); // Se crea el Thread pero no inicia
mythread.setName("Thread 1");
Thread myrunnable = new Thread(new MyRunnable(),"Thread 2"); // Thread creado       

mythread.start(); // Inicia el Thread (No necesariamente indica que haya empezado a ejecutarse) 
myrunnable.start();

¿Qué pasaría en caso de que en vez de llamar al método start(), intentemos ejecutar directamente el método run()? No tendríamos error ni una Excepción; simplemente se ejecutará en el mismo thread (hilo) desde el que se llama el método. ¿Y si intentamos llamar dos veces al método start() del mismo objeto Thread?

mythread.start(); 
mythread.start(); // Esta línea lanzará una excepción de tipo IllegalThreadStateException

Puntos a tener en cuenta sobre crear un Thread en Java

1) Este ejemplo no garantiza que el hilo mythread se inicie antes que el hilo myrunnable. Como se explicó, esto depende del planificador de Threads.

2) Un Thread pasará a estado muerto una vez que finaliza la ejecución del método run(), y por tanto, dicho Thread no puede volver a iniciar otra vez.