Hilos de Java

Hasta ahora hemos hablado siempre de procesos en un contexto abstracto.

Si estamos programando en un lenguaje de programación, p.ej., C++ o Java, se puede usar sus hilos (``threads'') como instancias de procesos. No obstante, existen más posibilidades de instanciar los procesos.

Un hilo es una secuencia de instrucciones que está controlada por un planificador. 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.

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)

Prácticas: codificar los ejemplos y ``jugar con el entorno'' y realizar un pingPONG perfecto.