Hilos de Java

Un hilo es una secuencia de instrucciones que está controlada por un planificador que se comporta como un flujo de control secuencial. El planificador gestiona el tiempo de ejecución del procesador y asigna de alguna manera dicho tiempo a los diferentes hilos actualmente presentes.

Normalmente los hilos de un proceso (en este contexto el proceso es lo que se suele llamar así en el ámbito de sistemas operativos) suelen tener acceso a todos los recursos disponibles al proceso, es decir, actuan sobre una memoria compartida. Los problemas y sorpresas de dicho funcionamiento veremos más adelante.

En Java los hilos están en el paquete

java.lang.thread

y se puede usar por ejemplo dos hilos para realizar un pequeño pingPONG:

Thread PingThread = new Thread();
PingThread.start();
Thread PongThread = new Thread();
PongThread.start();

Por defecto, un hilo nuevamente creado y lanzado aún siendo activado así no hace nada. Sin embargo, los hilos se ejecutan durante un tiempo infinito y hay que abortar el programa de forma bruta: control-C en el terminal.

Extendemos la clase y sobre-escribimos el método run()para que haga algo útil:

public class CD_PingThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("ping ");
    }
  }
}

El hilo hereda todo de la clase Thread, pero sobre-escribe el método run(). Hacemos lo mismo para el otro hilo:

public class CD_PongThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("PONG "); 
    } 
  }
}

Y reprogramamos el hilo principal:

CD_PingThread PingThread=new CD_PingThread();
PingThread.start();
CD_PongThread PongThread=new CD_PongThread();
PongThread.start();

Resultado (esperado):

• los dos hilos producen cada uno por su parte sus salidas en la pantalla

Resultado (observado):

• se ve solamente la salida de un hilo durante cierto tiempo
• parece que la salida dependa cómo el planificador está realizado en el entorno Java

Nuestro objetivo es: la ejecución del pingPONG independientemente del sistema debajo. Intentamos introducir una pausa para ``motivar'' el planificador para que cambie los hilos:

public class CD_PingThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("ping ");
      try {
        sleep(10);
      }
      catch(InterruptedException e) {
        return;
      }
    }
  }
}

public class CD_PongThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("PONG ");
      try {
        sleep(50);
      }
      catch(InterruptedException e) {
        return;
      }
    }
  }
}

Resultado (observado):

• se ve un poco más ping que PONG
• incluso si los dos tiempos de espera son iguales no se ve ningún pingPONG perfecto

Existe el método yield() (cede) para avisar explícitamente al planificador de que debe cambiar los hilos:

public class CD_PingThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("ping ");
      yield();
    }
  }
}

public class CD_PongThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("PONG ");
      yield();
    }
  }
}

Resultado (observado):

• se ve un ping y un PONG alternativamente, pero de vez en cuando aparecen dos pings o dos PONGs
• parece que el planificador re-seleccione el mismo hilo que ha lanzado el yield() (puede ser que el tercer hilo siendo el programa principal está intercalado de vez en cuando)
• dicho comportamiento depende del sistema concreto con el cual se está trabajando

refTareaPingpongPrácticas: codificar los ejemplos y realizar un pingPONG perfecto.