Tema 2. Procesos vs. hilos

• Los hilos se representan en Java mediante la clase Thread.
• Sus métodos junto con algunos de la clase Object nos permiten un manejo completo de los hilos.
• Para cada programa Java existe un hilo de ejecución denominado hilo principal.
• Diferencia entre objeto e hilo:
  • Un objeto es algo estático, con una serie de atributos y métodos.
  • Pero quien ejecuta esos métodos es el hilo de ejecución.

• Clase Thread de Java
• Dos posibilidades:
  • Heredar de Thread
  • Implementar la interfaz Runnable
• En ambos casos hay que definir el método run().

• Contiene el código del hilo
• Método invocado cuando se ejecuta el hilo
• El hilo termina cuando termina run

• Heredando de Thread y redefiniendo el método run

public class Filosofo extends Thread {
  ...
  public void run() { ... }
  ...
}

• Implementando la interfaz Runnable

public class Filosofo implements Runnable {
  ...
  public void run() { ... }
  ...
}

• Creación y ejecución

//creación
Thread filosofo = new Filosofo();             //herencia
Thread filosofo = new Thread(new Filosofo()); //interface

//ejecución para ambos casos
filosofo.start();

• Heredando de Thread y redefiniendo el método run

 1: class ThreadConHerencia extends Thread {
 2:   String palabra;
 3: 
 4:   public ThreadConHerencia (String p) {
 5:     palabra=p;
 6:   }
 7: 
 8:   public void run() {
 9:     for (int i=0; i < 10 ; i++) {
10:       System.out.print (palabra);
11:     }
12:   }
13: 
14:   public static void main(String[]args){
15:     Thread a=new ThreadConHerencia(“hilo1”);
16:     Thread b=new ThreadConHerencia(“hilo2”);
17: 
18:     a.start();
19:     b.start();
20:     System.out.println(“Fin del hilo principal”);
21:   }
22: }

• Se intercalan las salidas de los tres hilos creados, recordemos que tenemos el hilo principal y los dos creados

• Implementamos la interfaz Runnable, esta interfaz sólo tiene un método con la signatura public void run().
• Este método es el que como mínimo tenemos que implementar en la clase.

 1: public class ThreadConRunnable implements Runnable {
 2:   String palabra;
 3: 
 4:   public ThreadConRunnable (String p){
 5:     palabra=p;
 6:   }
 7: 
 8:   public void run() {
 9:     for(int i=0;i<10;i++)
10:     System.out.print(palabra);
11:   }

• Hasta aquí simplemente hemos creado una clase. Al contrario que antes, los objetos de esta clase no serán hilos ya que no hemos heredado de Thread.

• Si queremos que el objeto de esta clase se ejecute como un hilo independiente debemos crear un objeto de la clase Thread y pasarle como parámetro el objeto donde queremos que empiece su ejecución ese hilo.

 1: public static void main(String[]args){
 2:   ThreadConRunnable a=new ThreadConRunnable(“hilo1”);
 3:   ThreadConRunnable b=new ThreadConRunnable(“hilo2”);
 4: 
 5:   Thread t1=new Thread (a);
 6:   Thread t2=new Thread (b);
 7: 
 8:   t1.start();
 9:   t2.start();
10: 
11:   System.out.println(“Fin del hilo principal”);
12: }

• Se invoca al método start de la clase Thread que será el que se encarga de invocar al método run() de los objetos a y b respectivamente

• Si comparamos ambos métodos, la segunda forma puede parecer más confusa.
• Sin embargo es más apropiada debido a que en Java no hay herencia múltiple, al utilizar la primera opción nuestra clase ya no podría heredar de otras clases.
• Si necesitamos que haya herencia de otras clases deberemos usar siempre la segunda opción.

• A veces necesitamos que un objeto autónomo se ejecute automáticamente en un nuevo hilo, sin intervención del cliente:

 1: public class ObtejoAutonomo implements Runnable {
 2:   private Thread hilo;
 3: 
 4:   public ObjetoAutónomo() {
 5:     hilo = new Thread(this);
 6:     hilo.start();
 7:   }
 8: 
 9:   public void run() {
10:     if (hilo == Thread.currentThread()){
11:       //Hacer algo
12:     }
13:   }
14: 
15:   //ATENCIÓN
16: 
17:   public static void main(String []args){
18:     ObjetoAutónomo objeto = new ObjetoAutónomo();
19:   }
20: }

• Como vemos en este ejemplo, en la implementación del método run() hay que controlar cuál es el hilo que se está ejecutando y para ello nos servimos del método currentThread() de la clase Thread.
• Este método nos devuelve una referencia al hilo que está ejecutando ese código. Esto se hace para evitar que cualquier método de un hilo distinto haga una llamada a run() directamente.

• Método isAlive() para saber si un hilo está vivo o muerto
• Sistema de prioridades para el scheduler de la JVM: setPriority(prioridad)
• Método yield() para forzar la salida de un hilo de la CPU
• Otros métodos de utilidad: wait(), notify, sleep(milisegundos)

• Las prioridades de cada hilo en Java van de 1 (MIN_PRIORITY) a 10 (MAX_PRIORITY).
• La prioridad de un hilo inicialmente es la misma que la del hilo que lo creó.
• Por defecto, todo hilo tiene prioridad 5 (NORM_PRIORITY)
• La especificación de la máquina virtual no fuerza al uso de ningun algoritmo particular en la planificación de hebras.
• El planificador debe dar ventaja a las hebras con mayor prioridad.
• Si hay varias hebras con igual prioridad todas se deben ejecutar en algún momento.
• No se garantiza que hebras de prioridad baja pasen a ejecutarse si existe alguna hebra de mayor prioridad…, pero podría ser así.

• El código siguiente permite comprobar la implementación particular de nuestra máquina virtual

 1: public class ComprobarPrioridad implements Runnable {
 2:   int num;
 3:   ComprobarPrioridad(int c) { num = c; }
 4: 
 5:   public void run() {
 6:     while (true)
 7:     System.out.println(num);
 8:   }
 9: 
10:   public static void main(String[] args) {
11:     Thread nueva;
12:     for (int c = 0; c < 10; c++) {
13:       nueva = new Thread(new ComprobarPrioridad(c));
14:       if (c == 0)
15:         nueva.setPriority(Thread.MAX_PRIORITY);
16:       nueva.start();
17:     }
18:   }
19: } // class

• Atributos:
  • public static final int MIN_PRIORITY
  • public static final int NORM_PRIORITY
  • public static final int MAX_PRIORITY
• Constructores:

  public Thread():

  por defecto

  public Thread(String name):

  un nuevo hilo con nombre name

  public Thread(Runnable target):

  crea un nuevo hilo siendo target el que contiene el método run() que será invocado al lanzar el hilo con start()

  public Thread(Runnable target, String name):

  como el anterior, pero con nombre

• Métodos:

  public static Thread currentThread():

  retorna la referencia al hilo que se está ejecutando actualmente

  public String getName():

  retorna el nombre del hilo.

  int getPriority():

  retorna la prioridad del hilo

  public final boolean isAlive():

  chequea si el hilo está vivo

  public void run():

  contiene lo que el hilo debe hacer

• Métodos:

  public final void setName(String name):

  cambia el nombre del hilo por name

  public final void setPriority(int nuevaPrioridad):

  cambia la prioridad

  public static void sleep(long milis):

  cesa la ejecución milis milisengudos

  public void start():

  hace que el hilo comience la ejecución

  public static void yield ():

  hace que el hilo que se está ejecutando actualmente pase a estado de listo, permitiendo a otro hilo ganar el procesador

  public final void join():

  Espera a que el hilo termine.

1. Las asignaciones entre tipos primitivos son atómicas. En el caso de long y double puede haber excepciones.
2. Las asignaciones de referencias son atómicas.
3. Las asignaciones de variables volatile son atómicas.
4. Todas las operaciones de las clases de java.concurrent.Atomic* son atómicas.

Es conveniento que consultes la especificación de la versión de Java que uses.

• Todo lo relacionado con hilos se encuentra en el módulo: std::thread.

• Creamos un hilo mediante la llamada a la función std::thread::spawn.

  use std::thread;
  use std::time::Duration;
  
  fn main() {
      thread::spawn(|| {
          for i in 1..10 {
              println!("hi number {} from the spawned thread!", i);
              thread::sleep(Duration::from_millis(1));
          }
      });
  
      for i in 1..5 {
          println!("hi number {} from the main thread!", i);
          thread::sleep(Duration::from_millis(1));
      }
  }
  

• Hacemos use de Mutex.
• Este código no compila.
• ¿Por qué no lo hace?

use std::sync::Mutex;
use std::thread;

fn main() {
    let counter = Mutex::new(0);
    let mut handles = vec![];

    for _ in 0..10 {
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

• Esta versión si lo hace.
• Fíjate que usamos Arc y no Rc. La diferencia está en los traits Send y Sync.

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

• En determinadas ocasiones al trabajar con hilos te puede resultar útil el patron llamado mutabilidad interior.
• Este patrón se implementa por tipos como: std::cell::RefCell.