Propiedades de los hilos en Java

Nombres de hilos

Al crear un hilo en Java podemos darle un nombre. El nombre nos puede ayudar a diferenciarlo entre los diferentes hilos que se están ejecutando. Por ejemplo, si varios hilos escriben con system.out, puede ser útil saber qué hilo escribió el hilo. Un ejemplo:

Thread thread = new Thread("Hilo Nuevo") {
    public void run() {
        System.out.println("Ejecutando hilo con nombre " + getName());
    }
};
thread.start();

Acá vemos cómo pasamos la cadena "Hilo Nuevo" como argumento al constructor de Thread. Esta cadena es el nombre del hilo. El nombre se puede obtener usando el método getName() de la clase Thread. También podemos pasar un nombre a un Thread usando una implementación de Runnable. Un ejemplo:

Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, "Hilo Nuevo");

thread.start();
System.out.println("Hilo de nombre: " + thread.getName());

Notamos acá que, como la clase MyRunnable no es una subclase de Thread, no tiene acceso al método getName(). Sin embargo, el hilo creado con el nombre "Hilo Nuevo" sí tiene acceso a este método.

Método Thread.currentThread()

El méþodo Thread.currentThread() devuelve una referencia a la instancia de Thread que ejecutando currentThread(). Así podemos obtener acceso al objeto Thread que represente al hilo que se ejecuta en el bloque de código dado. Aquí hay un ejemplo:

Thread thread = Thread.currentThread();

Una vez que referenciamos un objeto Thread, podemos llamar sus métodos. Por ejemplo, podemos obtener el nombre del hilo actual:

Thread thread = Thread.currentThread();
System.out.println("Hilo actual: " + thread.getName());

Ejemplo de uso hilos en Java

Vamos a ver un ejemplo de uso de hilos. En el ejemplo, primero se imprime el nombre del hilo que ejecuta el método main(). Este hilo es asignado por la JVM. Luego se inician 10 hilos y se les da un número como nombre (""+ i). Cada hilo, luego imprime su nombre, y deja de ejecutarse.

public class Main {
    public static void main(String[] args) {
        Thread mainThread = Thread.currentThread();
        System.out.println("Hilo principal: " + mainThread.getName());

        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread("" + i) {
                public void run() {
                    System.out.println("Ejecutando hilo con nombre " + getName());
                }
            };
            thread.start();
        }
    }
}

Observemos bien, que, incluso si los hilos se inician secuencialmente (1, 2, 3, etc), tal vez no se ejecuten en ese orden. La JVM decide cuándo y en qué orden se ejecutan los hilos. Por lo tanto, el orden en que se imprimen los nombres de los hilos puede variar.

Pausar un hilo

Un hilo se puede pausar a sí mismo llamando al método estático Thread.sleep(). El método sleep() toma un argumento entero que representa la cantidad de milisegundos que el hilo debe dormir. El método intentará dormir ese número de milisegundos antes de reanudar la ejecución. El méþodo no es 100% preciso, pero aún así es útil. Aquí hay un ejemplo:

Thread thread = new Thread() {
    public void run() {
        System.out.println("Hilo durmiendo");
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Hilo finalizado");
    }
};
thread.start();

En este ejemplo, el hilo se duerme por 1000 milisegundos (1 segundo) antes de imprimir “Hilo finalizado”.

Detener un hilo

Detener un hilo en Java necesita algo de preparación en la implementación del código. La clase Thread contiene un método stop(), pero está deprecado. Este método no brinda ninguna garantía de que el hilo se detenga de manera segura. Eso significa que todos los objetos Java a los que tuvo acceso ese hilo durante su ejecución quedarán en un estado desconocido. Si otros hilos en la aplicación también tienen acceso a los mismos objetos, nuestra aplicación puede fallar de manera impredecible.

En lugar de llamar al método stop(), tendremos que implementar el código para detenerlo. Este sería un ejemplo de una clase que implementa Runnable con un método stopThread() que le da la señal para que se detenga. El hilo comprobará esta señal y se detendrá cuando esté listo.

public class MyRunnable implements Runnable {

    private boolean stop = false;

    public synchronized void stopThread() {
        this.stop = true;
    }

    private synchronized boolean keepRunning() {
        return this.stop == false;
    }

    @Override
    public void run() {
        while (keepRunning()) {
            // Seguir ejecutando lo que sea que haga en el hilo
            System.out.println("Hilo en ejecución");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Observemos los métodos stopThread() y keepRunning(). El método stopThread() está pensado para ser llamado desde otro hilo diferente al que ejecuta el método run() de la clase MyRunnable. El método keepRunning() es llamado internamente por el hilo que ejecuta run(). Siempre que no se llame a stopThread(), el método keepRunning() devolverá true, y el hilo seguirá ejecutándose. Cuando se llama a stopThread(), el método keepRunning() devolverá false, y el hilo se detendrá.

Aquí tenemos un ejemplo de iniciio de un hilo que ejecuta una instancia de MyRunnable, y la detiene luego de un tiempo:

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

try {
    Thread.sleep(10_000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

myRunnable.stopThread();

Este ejemplo primero crea una instancia de MyRunnable, luego pasa esa instancia a un hilo y lo inicia. Luego, el hilo principal se duerme por 10 segundos. Durante este tiempo, el hilo creado con MyRunnable se ejecuta y se imprime “Hilo en ejecución” cada 2 segundos. Después de 10 segundos, el hilo principal llama a stopThread(), y el hilo creado con MyRunnable se detiene.

Método join() de la clase Thread

El método join() de la clase Thread se puede usar para esperar a que un hilo termine su ejecución antes de que el hilo actual continúe. Aquí hay un ejemplo:

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

try {
    thread.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

En este ejemplo, el hilo principal espera a que el hilo creado con MyRunnable termine su ejecución antes de continuar. Si el hilo creado con MyRunnable ya ha terminado, el método join() regresa inmediatamente. Si el hilo aún está en ejecución, el hilo principal se bloquea hasta que el hilo creado con MyRunnable termine.