10 Programación Multihilo (Multihebra)

• Un programa multihilo contiene dos o más partes que pueden ejecutarse concurrentemente (aunque sólo tengamos una CPU).
• Esto permite escribir programas muy eficientes que utilizan al máximo la CPU, reduciendo al mínimo, el tiempo que está sin usarse.
• Java incluye características directamente en el lenguaje y API, para construir programas multihilo (a diferencia de otros lenguajes).

1 Hebras en CLDC

• Las máquinas virtuales de CLDC requieren proporcionar un entorno de programación multitarea incluso si el dispositivo no dispone de ella.
• Los mecanismos usados en J2SE para soportar la multitarea (palabra reservada synchronized, los métodos Object.wait(), Object.notify() y Object.notifyAll(), y la clase Thread) están incluidos en CLDC.

Algunas diferencias

• Sin embargo CLDC no soporta grupos de hebras o la clase ThreadGroup.
• El método setName() no existe. El método getName() existe sólo en CLDC 1.1
• Los métodos (deprecated) resume(), suspend y stop() se han eliminado.
• Los métodos destroy(), interrupt() y isInterrupted() no existen.
• El método dumpStack() se ha eliminado.

2 El hilo principal

• El hilo principal es lanzado siempre por la JVM (Java Virtual Machine) al ejecutar una aplicación.
• Desde este hilo se crearán el resto de hilos del programa.
• Debe ser el último que termine su ejecución. Cuando el hilo principal finaliza, termina el programa.

Ejemplo de acceso al hilo principal: P44/CurrentThreadDemo.java

class CurrentThreadDemo {
  public static void main(String args[]) {
    Thread t = Thread.currentThread();
    System.out.println("Hilo actual: " + t);
    try {
      for(int n = 5; n > 0; n--) {
        System.out.println(n);
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal");}
  }
}

Salida del programa

Hilo actual: Thread[Thread-0,5]
5
4
3
2
1

• En CLDC, cuando se usa t como argumento de println() aparece el nombre de la hebra y su prioridad.
• En CLDC no existe un método setName(String) en la clase Thread como en J2SE, lo que hace que sólo podamos asociar un nombre con el constructor Thread(String).

3 Creación de un hilo

En Java hay dos formas de crear nuevos hilos:

• Implementando el interfaz Runnable.
• Extendiendo la clase Thread.

1 Implementación del interfaz Runnable

• Consiste en declarar una clase que implemente Runnable y sobreescribir el método run():

  public abstract void run()
  

• Dentro de run() incluimos el código a ejecutar por el nuevo hilo.
• Luego se crea un objeto de la clase Thread dentro de esa clase. Al constructor de Thread le pasamos como argumento el objeto creado de la nueva clase (instancia de una clase que implemente Runnable):

  Thread(Runnable objetoHilo,String nombreHilo)
  

• Finalmente llamamos al método start() con el objeto anterior.

  synchronized void start()
  

Ejemplo: P45/ThreadDemo.java

class NewThread implements Runnable {
  Thread t;
  NewThread() {
    t = new Thread(this, "Hilo hijo");// Crea un nuevo hilo
    System.out.println("Hilo hijo: " + t);
    t.start(); // Comienza el hilo
  }
  public void run() {//Punto de entrada del segundo hilo
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println("Hilo hijo: " + i);
        Thread.sleep(500); }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo hijo."); }
    System.out.println("Sale del hilo hijo.");
  }
}
class ThreadDemo {
  public static void main(String args[]) {
    new NewThread(); // crea un nuevo hilo
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println("Hilo principal: " + i);
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal.");
    }
    System.out.println("Sale del hilo principal.");
  }
}

Salida del anterior programa

Hilo hijo: Thread{Hilo hijo,5]
Hilo principal:5
Hilo hijo:5
Hilo hijo:4
Hilo principal:4
Hilo hijo:3
Hilo hijo:2
Hilo principal:3
Hilo hijo:1
Sale del hilo hijo.
Hilo principal:2
Hilo principal:1
Sale del hilo principal.

2 Extensión de la clase Thread

• Consiste en declarar una clase que herede de la clase Thread y sobreescribir también el método run():

• Dentro de run() incluimos el código a ejecutar por el nuevo hilo.
• Luego se crea un objeto de la nueva clase.
• Finalmente llamamos al método start() con el objeto anterior.

Ejemplo: P46/ExtendThread.java

class NewThread extends Thread {
  NewThread() {
    super("Hilo Demo"); // Crea un nuevo hilo
    System.out.println("Hilo hijo: " + this);
    start(); // Comienza el hilo
  }
  public void run() {// Este es el punto de entrada del segundo hilo
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println("Hilo hijo: " + i);
        Thread.sleep(500); }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo hijo.");
    }
    System.out.println("Sale del hilo hijo.");
  }
}
class ExtendThread {
  public static void main(String args[]) {
    new NewThread(); // crea un nuevo hilo
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println("Hilo principal: " + i);
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal.");
    }
    System.out.println("Sale del hilo principal.");
  }
}

3 Elección de una de las dos opciones

Depende del tipo de clase que se vaya a crear.

• Si la clase hereda de otra, no queda más remedio que implementar Runnable.
• Normalmente es más sencillo heredar de Thread.
• Pero algunos programadores piensan que una clase no debe extenderse si no va a ser ampliada o modificada. Por eso, si no vamos a sobreescribir ningún otro método de Thread, quizás sería mejor implementar Runnable.

4 Creación de múltiples hilos

Un programa en Java puede crear tantos hilos como quiera.

Ejemplo de creación de tres hilos: P47/MultiThreadDemo.java

class NewThread implements Runnable {
  String name; // nombre del hilo
  Thread t;
  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("Nuevo hilo: " + t);
    t.start(); // Comienza el hilo
  }
  // Este es el punto de entrada del hilo.
  public void run() {
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println(name + ": " + i);
        Thread.sleep(1000);
      }
    }

    catch (InterruptedException e) {
      System.out.println(name + "Interrupción del hilo hijo" +name);
    }
    System.out.println("Sale del hilo hijo" + name);
  }
}
class MultiThreadDemo {
  public static void main(String args[]) {
    new NewThread("Uno"); // comienzan los hilos
    new NewThread("Dos");
    new NewThread("Tres");
    try {
      // espera un tiempo para que terminen los otros hilos
      Thread.sleep(10000);
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal");
    }
    System.out.println("Sale del hilo principal.");
  }
}

Salida del programa

Nuevo hilo: Thread[Uno,5]
Nuevo hilo: Thread[Dos,5]
Nuevo hilo: Thread[Tres,5]
Uno: 5
Dos: 5
Tres: 5
Uno: 4
Dos: 4
Tres: 4
Uno: 3
Dos: 3
Tres: 3
Uno: 2
Dos: 2
Tres: 2
Uno: 1
Dos: 1
Tres: 1
Sale del hilo.Uno
Sale del hilo.Dos
Sale del hilo.Tres
Sale del hilo principal.

5 Utilización de isAlive() y join()

Hay dos formas de determinar si un método ha terminado.

• Con el método isAlive(). Devuelve true si el hilo al que se hace referencia está todavía ejecutándose.

  final boolean isAlive() throws InterruptedException
  

• Con el método join(). Este método detiene el hilo actual hasta que termine el hilo sobre el que se llama join(). Es usado por tanto para que unos hilos esperen a la finalización de otros.

  final void join throws InterruptedException
  

Ejemplo de uso de isAlive() y join(): P48/DemoJoin.java

class NewThread implements Runnable {
  String name; // nombre del hilo
  Thread t;
  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("Nuevo hilo: " + t);
    t.start(); // Comienza el hilo
  }

  public void run() {// Este es el punto de entrada del hilo
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println(name + ": " + i);
        Thread.sleep(1000); }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo"+name); }
    System.out.println("Sale del hilo " + name);
  }
}
class DemoJoin {
  public static void main(String args[]) {
    NewThread ob1 = new NewThread("Uno");
    NewThread ob2 = new NewThread("Dos");
    NewThread ob3 = new NewThread("Tres");
    System.out.println("El hilo Uno está vivo: " + ob1.t.isAlive());
    System.out.println("El hilo Dos está vivo: " + ob2.t.isAlive());
    System.out.println("El hilo Tres está vivo: " + ob3.t.isAlive());
    try {// espera hasta que terminen los otros hilos
      System.out.println("Espera finalización de los otros hilos.");
      ob1.t.join(); ob2.t.join(); ob3.t.join();
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal"); }
    System.out.println("El hilo Uno está vivo: " + ob1.t.isAlive());
    System.out.println("El hilo Dos está vivo " + ob2.t.isAlive());
    System.out.println("El hilo Tres está vivo: " + ob3.t.isAlive());
    System.out.println("Sale del hilo principal.");
  }
}

Salida del programa

Nuevo hilo: Thread[Uno,5]
Nuevo hilo: Thread[Dos,5]
Nuevo hilo: Thread[Tres,5]
El hilo Uno está vivo: true
El hilo Dos está vivo: true
El hilo Tres está vivo: true
Espera finalización de los otros hilos.
Uno: 5
Dos: 5
Tres: 5
Uno: 4
Dos: 4
Tres: 4
Uno: 3
Dos: 3
Tres: 3
Uno: 2
Dos: 2
Tres: 2
Uno: 1
Dos: 1
Tres: 1
Sale del hilo Uno
Sale del hilo Dos
Sale del hilo Tres
El hilo Uno está vivo: false
El hilo Dos está vivo false
El hilo Tres está vivo: false
Sale del hilo principal.

6 Prioridades de los hilos

• La prioridad de un hilo es un valor entero que indica la prioridad relativa de un hilo respecto a otro.
• Se utiliza para decidir cuando pasar a ejecutar otro hilo (cambio de contexto).
  • Cuando un hilo cede el control (por abandono explícito o por bloqueo en E/S), se ejecuta a continuación el que tenga mayor prioridad.
  • Un hilo puede ser desalojado por otro con prioridad más alta, tan pronto como éste desee hacerlo.
• Pero en la práctica la cantidad de CPU que recibe cada hilo depende además de otros factores como la forma en que el sistema operativo implementa la multitarea.
• Para establecer la prioridad de un hilo usamos setPriority() de la clase Thread .

  final void setPriority(int level)
  

• level puede variar entre MIN_PRIORITY y MAX_PRIORITY (1 y 10 en la actualidad). La prioridad por defecto es NORM_PRIORITY (5 actualmente).
• Para obtener la prioridad de un hilo:

  final int getPriority()
  

Ejemplo: P49/HiLoPri.java

class clicker implements Runnable {
  int click = 0;
  Thread t;
  private volatile boolean running = true;
  public clicker(int p) {
    t = new Thread(this);
    t.setPriority(p);
  }

  public void run() {
    while (running) {
      click++;
    }
  }
  public void stop() {
    running = false;
  }
  public void start() {
    t.start();
  }
}
class HiLoPri {
  public static void main(String args[]) {
    Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
    clicker hi = new clicker(Thread.NORM_PRIORITY + 2);
    clicker lo = new clicker(Thread.NORM_PRIORITY - 2);
    lo.start();
    hi.start();
    try {
      Thread.sleep(10000);
    } catch (InterruptedException e) {
        System.out.println("Hilo principal interrumpido.");}
    lo.stop();
    hi.stop();
    try {
      hi.t.join();
      lo.t.join();
    } catch (InterruptedException e) {
      System.out.println("InterruptedException capturada");
    }
    System.out.println("Hilo de prioridad baja: " + lo.click); 
    System.out.println("Hilo de prioridad alta: " + hi.click);
  }
}

Salida del programa en linux Redhat 8.0

Hilo de prioridad baja: 9636208
Hilo de prioridad alta: 22480211

7 Sincronización

• Cuando dos o más hilos necesitan acceder a un recurso compartido, entonces necesitan alguna forma de asegurar que el recurso se usa sólo por un hilo al mismo tiempo: Sincronización.
• Un monitor (semáforo) es un objeto usado como un cerrojo de exclusión mutua. Sólo un hilo puede poseer el monitor en un momento determinado.
• Cuando un hilo entra en el monitor, los demás hilos que intentan entrar en él, quedan suspendidos hasta que el primer hilo lo deja.
• En Java el código puede sincronizarse de dos formas:
  • Con métodos sincronizados.
  • Con sentencia synchronized.

1 Uso de métodos sincronizados

• Todos los objetos de Java tienen asociado su propio monitor implícito.
• Para entrar en el monitor de un objeto sólo hay que llamar a un método synchronized.
• Cuando un hilo esté ejecutando un método sincronizado, todos los demás hilos que intenten ejecutar cualquier método sincronizado del mismo objeto tendrán que esperar.

Ejemplo de programa que no usa sincronización: P50/Synch.java

class Callme {
  void call(String msg) {
    System.out.print("[" + msg);
    try {
      Thread.sleep(1000);
    } catch(InterruptedException e) {
      System.out.println("Interrumpido");
    }
    System.out.println("]");
  }
}
class Caller implements Runnable {
  String msg;
  Callme target;
  Thread t;
  public Caller(Callme targ, String s) {
    target = targ;
    msg = s;
    t = new Thread(this);
    t.start();
  }
  public void run() {
    target.call(msg);
  }
}

class Synch {
  public static void main(String args[]) {
    Callme target = new Callme();
    Caller ob1 = new Caller(target, "Hola");
    Caller ob2 = new Caller(target, "Mundo");
    Caller ob3 = new Caller(target, "Sincronizado");
    try {
      ob1.t.join();
      ob2.t.join();
      ob3.t.join();
    } catch(InterruptedException e) {
      System.out.println("Interrumpido");
    }
  }
}

Salida del anterior programa

[Hola[Mundo[Sincronizado]
]
]

• El resultado de este programa muestra que la salida de los tres mensajes aparece mezclada, ya que los tres hilos están ejecutando el método call() del mismo objeto a la vez.
• Solución: Restringimos el acceso a call() a un sólo hilo en un momento determinado.

  Ejemplo: P51/Synch.java

  class Callme {
      synchronized void call(String msg) {
      ...
  

• Nueva salida:

  [Hola]
  [Mundo]
  [Sincronizado]
  

2 Sentencia synchronized

• A veces la solución de sincronizar un método no es posible porque no tenemos el código fuente de la clase, y no podemos hacer que el método sea sincronizado.
• En ese caso podemos usar la sentencia synchronized

  synchronized(objeto){
    // sentencias que se sincronizan
  }
  

• objeto es el objeto que sincronizamos.
• Esta sentencia hace que cualquier llamada a algún método de objeto se ejecutará después de que el hilo actual entre en el monitor de objeto.

Ejemplo que hace lo mismo de antes: P52/Synch1.java

class Callme {
  void call(String msg) {
    System.out.print("[" + msg);
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      System.out.println("Interrumpido");
    }
    System.out.println("]");
  }
}
class Caller implements Runnable {
  String msg;
  Callme target;
  Thread t;
  public Caller(Callme targ, String s) {
    target = targ;
    msg = s;
    t = new Thread(this); t.start();
  }

  public void run() {
    synchronized(target) { target.call(msg);}
  }
}
class Synch1 {
  public static void main(String args[]) {
    Callme target = new Callme();
    Caller ob1 = new Caller(target, "Hola");
    Caller ob2 = new Caller(target, "Sincronizado");
    Caller ob3 = new Caller(target, "Mundo");
    try {
      ob1.t.join();
      ob2.t.join();
      ob3.t.join();
    } catch(InterruptedException e) {
      System.out.println("Interrumpido");
    }
  }
}

8 Comunicación entre hilos

• Los hilos pueden comunicarse entre sí mediante el uso de los métodos wait(), notify() y notifyAll() de la clase Object (son métodos finales).
  • wait() dice al hilo llamante que deje el monitor y que pase a estado suspendido (dormido) hasta que otro hilo entre en el mismo monitor y llame a notify().
  • notify() despierta el primer hilo que llamó a wait() sobre el mismo objeto.
  • notifyAll() despierta todos los hilos que llamaron a wait() sobre el mismo objeto.
• Estos métodos sólo pueden ser llamados desde métodos sincronizados.

Productor/consumidor de un sólo carácter (versión errónea): P53/PC.java

class Q {
  int n;
  synchronized int get() {
    System.out.println("Obtengo: " + n);
    return n;
  }
  synchronized void put(int n) {
    this.n = n;
    System.out.println("Pongo: " + n);
  }
}
class Producer implements Runnable {
  Q q;
  Producer(Q q) {
    this.q = q;
    new Thread(this, "Productor").start();
  }
  public void run() {
    int i = 0;
    while(true) {
      q.put(i++);
    }
  }
}

class Consumer implements Runnable {
  Q q;
  Consumer(Q q) {
    this.q = q;
    new Thread(this, "Consumidor").start();
  }
  public void run() {
    while(true) {
      q.get();
    }
  }
}
class PC {
  public static void main(String args[]) {
    Q q = new Q();
    new Producer(q);
    new Consumer(q);
    System.out.println("Pulsa Control-C para parar.");
  }
}

Salida del programa

Pongo: 1
Obtengo: 1
Obtengo: 1
Obtengo: 1
Obtengo: 1
Obtengo: 1
Pongo: 2
Pongo: 3
Pongo: 4
Pongo: 5
Pongo: 6
Pongo: 7
Obtengo: 7

Solución correcta con wait y notify: P54/PCFixed.java

class Q {
  int n;
  boolean valueSet = false;
  synchronized int get() {
    if(!valueSet)
      try {
        wait();
      } catch(InterruptedException e) {
        System.out.println("InterruptedException capturada");
      }
    System.out.println("Obtengo: " + n);
    valueSet = false;
    notify();
    return n;
  }
  synchronized void put(int n) {
    if(valueSet)
      try {
        wait();
      } catch(InterruptedException e) {
        System.out.println("InterruptedException capturada");
      }
    this.n = n;
    valueSet = true;
    System.out.println("Pongo: " + n);
    notify();
  }
}
class Producer implements Runnable {
  Q q;
  Producer(Q q) {
    this.q = q;
    new Thread(this, "Productor").start();
  }
  public void run() {
    int i = 0;
    while(true) {
      q.put(i++);
    }
  }
}
class Consumer implements Runnable {
  Q q;
  Consumer(Q q) {
    this.q = q;
    new Thread(this, "Consumidor").start();
  }
  public void run() {
    while(true) {
      q.get();
    }
  }
}
class PCFixed {
  public static void main(String args[]) {
    Q q = new Q();
    new Producer(q);
    new Consumer(q);
    System.out.println("Pulsa Control-C para parar.");
  }
}

Salida del programa

Pongo: 1
Obtengo: 1
Pongo: 2
Obtengo: 2
Pongo: 3
Obtengo: 3
Pongo: 4
Obtengo: 4
Pongo: 5
Obtengo: 5
Pongo: 6
Obtengo: 6
Pongo: 7
Obtengo: 7

1 Interbloqueos

• Un interbloqueo ocurre cuando dos hilos tienen una dependencia circular sobre un par de objetos sincronizados.
• Por ejemplo, un hilo entra en el monitor del objeto X y otro entra en el monitor de Y. Si X intenta llamar cualquier método sincronizado de Y, se bloqueará. Sin embargo, si el hilo de Y, intenta ahora llamar cualquier método sincronizado de X, los dos hilos quedarán detenidos para siempre.

Ejemplo de interbloqueo: P55/Deadlock.java

class A {
  synchronized void foo(B b) {
    String name = Thread.currentThread().getName();
    System.out.println(name + " entró en A.foo");
    try {
      Thread.sleep(1000);
    } catch(Exception e) {
      System.out.println("A Interrumpido");
    }
    System.out.println(name + " intentando llamar a B.last()");
    b.last();
  }
  synchronized void last() {
    System.out.println("Dentro de A.last");
  }
}
class B {
  synchronized void bar(A a) {
    String name = Thread.currentThread().getName();
    System.out.println(name + " entró en B.bar");
    try {
      Thread.sleep(1000);
    } catch(Exception e) {
      System.out.println("B Interrumpido");
    }
    System.out.println(name + " intentando llamar a A.last()");
    a.last();
  }
  synchronized void last() {
    System.out.println("Dentro de A.last");
  }
}

class Deadlock implements Runnable {
  A a = new A();
  B b = new B();
  Deadlock() {
    Thread t = new Thread(this, "RacingThread");
    t.start();
    a.foo(b); 
    System.out.println("Regreso al hilo principal");
  }
  public void run() {
    b.bar(a); 
    System.out.println("Regreso al otro hilo");
  }
  public static void main(String args[]) {
    new Deadlock();
  }
}

Salida del programa hasta que queda bloqueado

Thread-0 entró en A.foo
RacingThread entró en B.bar
Thread-0 intentando llamar a B.last()
RacingThread intentando llamar a A.last()

9 Suspender, reanudar y terminar hilos

• La suspensión de la ejecución de un hilo es útil en algunos casos.

  Por ejemplo, un hilo puede usarse para mostrar la hora actual. Si el usuario no desea verla en un momento determinado, entonces tal hilo debería suspenderse.

• Una vez suspendido un hilo, éste puede volver a reanudar su ejecución.
• Para poder suspender, reanudar y terminar la ejecución de un hilo usaremos una variable bandera que indica el estado de ejecución del hilo. Haremos uso también de los métodos wait() y notify() o notifyAll() de la clase Object.

Ejemplo de uso: P57/SuspendResume.java

class NewThread implements Runnable {
  String name; // nombre del hilo
  Thread t;
  boolean suspendFlag;
  
  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("Nuevo hilo: " + t);
    suspendFlag = false;
    t.start(); // Comienza el hilo
  }

  // Este es el punto de entrada del hilo.
  public void run() {
    try {
      for(int i = 15; i > 0; i--) {
        System.out.println(name + ": " + i);
        Thread.sleep(200);
        synchronized(this) {
          while(suspendFlag) {
            wait();
          }
        }
      }
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo" + name);
    }
    System.out.println("Sale del hilo" + name);
  }
  void mysuspend() {
    suspendFlag = true;
  }
  synchronized void myresume() {
    suspendFlag = false;
    notify();
  }
}
class SuspendResume {
  public static void main(String args[]) {
    NewThread ob1 = new NewThread("Uno");
    NewThread ob2 = new NewThread("Dos");
    try {
      Thread.sleep(1000);
      ob1.mysuspend();
      System.out.println("Suspende el hilo Uno");
      Thread.sleep(1000);
      ob1.myresume();
      System.out.println("Reanuda el hilo Uno");
      ob2.mysuspend();
      System.out.println("Suspende el hilo Dos");
      Thread.sleep(1000);
      ob2.myresume();
      System.out.println("Reanuda el hilo Dos");
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal");
    }
    // espera hasta que terminen los otros hilos
    try {
      System.out.println("Espera finalización de los otros hilos.");
      ob1.t.join();
      ob2.t.join();
    } catch (InterruptedException e) {
      System.out.println("Interrupción del hilo principal");
    }
    System.out.println("Sale del hilo principal.");
  }
}