¿Qué son los hilos en Java?

En el proceso de aprender a programar en Java existen muchas herramientas que nos facilitan la vida. Una de ella son los hilos en Java, también conocidos como Threads (sí, ya sabemos a qué aplicación te recordó el nombre…), estos son secuencias que ayudan a manejar y crear múltiples procesos.

Veamos el funcionamiento de los hilos en Java y para qué pueden ser útiles.

¿Qué son los hilos en Java?

Los hilos, conocidos por algunos como threads, son secuencias de ejecución dentro de un programa. El lenguaje de programación Java nos permite crear y manejar múltiples hilos dentro de un mismo proceso, situación que nos facilita enormemente la ejecución concurrente y paralela de tareas. Cada uno de los hilos dentro de un proceso tiene su propio contador de programa, su propia pila de llamadas y sus propios registros; sin embargo, comparte el espacio de direcciones y recursos del proceso.

Existen muchas ventajas al usar hilos en Java, entre ellas:

1. Eficiencia y rendimiento: Los hilos nos permiten realizar múltiples tareas al mismo tiempo, con lo cual podemos aprovechar mucho mejor los recursos del sistema.
2. Mejor respuesta: Aplicaciones como interfaces de usuario pueden mantenerse responsivas mientras realizan tareas intensivas en segundo plano.
3. Paralelismo: En sistemas con múltiples CPU, los hilos pueden ejecutarse verdaderamente en paralelo, mejorando muchísimo el rendimiento.

Cada hilo en Java tiene una prioridad que va de 1 (mínima) a 10 (máxima). La prioridad influye en la probabilidad de que el hilo sea seleccionado para ejecutarse, aunque no garantiza el orden de ejecución.

Cómo crear hilos en Java

Existen dos formas de crear hilos en Java: extendiendo la clase Thread o implementando la interfaz Runnable.

Extendiendo la clase Thread

//hilos en Java
public class MiHilo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.print("0-");
        }
    }

    public static void main(String[] args) {
        MiHilo hilo = new MiHilo();
        hilo.start();
    }
}

Veamos parte por parte:

1. Definición de la clase MiHilo:

   public class MiHilo extends Thread {

Aquí estamos creando una nueva clase llamada MiHilo que extiende la clase Thread. Esto significa que MiHilo es una subclase de Thread y, por lo tanto, hereda todas sus capacidades.

2. Sobrescribir el método run:

//hilos en Java   
@Override
   public void run() {
       for (int i = 0; i < 1000; i++) {
           System.out.print("0-");
       }
   }

El método run es donde se coloca el código que queremos que se ejecute en el nuevo hilo. En este ejemplo, simplemente imprimimos «0-» mil veces. El método run se ejecutará cuando el hilo se inicie.

3. Método main:

//hilos en Java
public static void main(String[] args) {
       MiHilo hilo = new MiHilo();
       hilo.start();
   }

En el método main, creamos una instancia de MiHilo y luego llamamos al método start en esa instancia.

Veamos la explicación del flujo:

1. Creación de la instancia del hilo:

   MiHilo hilo = new MiHilo();

Aquí creamos una nueva instancia de MiHilo. Esto significa que hemos creado un objeto que es un hilo, pero aún no se ha iniciado su ejecución.

2. Inicio del hilo:

   hilo.start();

Llamamos al método start en la instancia del hilo. Esto es crucial porque start es el método que realmente inicia el hilo y hace que el sistema operativo ejecute el método run en un nuevo hilo de ejecución.

3. Ejecución del método run:
   Una vez que se llama a start, el sistema operativo comienza la ejecución del método run en un nuevo hilo. En nuestro ejemplo, esto significa que el programa imprimirá «0-» mil veces de manera concurrente con cualquier otro código que se esté ejecutando.

Importancia de usar start() en lugar de run()

Un error común al trabajar con hilos en Java es llamar directamente al método run en lugar de start. Si llamas a run directamente, el método se ejecutará en el hilo actual, no en un nuevo hilo. Veamos la diferencia:

• Llamada directa a run:

  hilo.run();  // Esto NO inicia un nuevo hilo, se ejecuta en el hilo actual

• Llamada a start:

  hilo.start();  // Esto inicia un nuevo hilo y ejecuta run en ese nuevo hilo

Llamar a start es esencial para que el método run se ejecute en un nuevo hilo de ejecución, permitiendo así la verdadera concurrencia

Implementando la interfaz Runnable

//hilos en Java
public class MiRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.print("1-");
        }
    }

    public static void main(String[] args) {
        Thread hilo = new Thread(new MiRunnable());
        hilo.start();
    }
}

Desglosemos un poco el código:

1. Implementación de la interfaz Runnable:

   public class MiRunnable implements Runnable {

Aquí estamos creando una nueva clase llamada MiRunnable que implementa la interfaz Runnable. Esta interfaz tiene un solo método, run, que debemos sobrescribir para definir el código que queremos que se ejecute en el nuevo hilo.

2. Sobrescribir el método run:

//hilos en Java
@Override
   public void run() {
       for (int i = 0; i < 1000; i++) {
           System.out.print("1-");
       }
   }

El método run es donde se coloca el código que queremos que se ejecute en el nuevo hilo. En este ejemplo, simplemente imprimimos «1-» mil veces. Este método se ejecutará cuando el hilo se inicie.

3. Método main:

   public static void main(String[] args) {
       Thread hilo = new Thread(new MiRunnable());
       hilo.start();
   }

En el método main, creamos una instancia de Thread, pasando una instancia de MiRunnable como argumento al constructor de Thread. Luego llamamos al método start en esa instancia de Thread.

Explicación del flujo:

1. Implementación de la interfaz Runnable:

   public class MiRunnable implements Runnable {

Al implementar la interfaz Runnable, nos aseguramos de que nuestra clase pueda ser ejecutada por un hilo. Esta es una forma más flexible de crear hilos en comparación con extender la clase Thread.

2. Definición del método run:

   @Override
   public void run() {
       for (int i = 0; i < 1000; i++) {
           System.out.print("1-");
       }
   }

Aquí definimos el método run que contiene el código que se ejecutará en el nuevo hilo. En este caso, estamos imprimiendo «1-» mil veces.

3. Creación del hilo y ejecución:

   public static void main(String[] args) {
       Thread hilo = new Thread(new MiRunnable());
       hilo.start();
   }

• new MiRunnable(): Crea una nueva instancia de MiRunnable, que implementa Runnable.
• new Thread(new MiRunnable()): Crea una nueva instancia de Thread, pasándole la instancia de MiRunnable. Esto le dice al hilo qué código ejecutar.
• hilo.start(): Inicia el hilo, lo que provoca que el método run de MiRunnable se ejecute en un nuevo hilo de ejecución.

Entonces, ¿cuál usar?

Eso dependerá de tus necesidades y lo que requieras en el momento:

1. Extender la clase Thread:
   • Limitado a una sola herencia (Java no soporta herencia múltiple).
   • Directamente sobrecargamos el método run en la clase que extiende Thread.
2. Implementar la interfaz Runnable:
   • Más flexible, ya que una clase puede implementar múltiples interfaces.
   • Separa la lógica de ejecución (Runnable) de la capacidad de manejo de hilos (Thread).
   • Recomendada en casos donde la clase ya extiende otra clase.

Si quieres seguir aprendiendo sobre Java y todos sus secretos, te invitamos a unirte al bootcamp java que hemos preparado especialmente para ti, en donde podrás aprender todo lo que necesitas para incursionar en el mercado tecnológico con los mejores salarios del sector. ¡No esperes más y únete ahora!