Skip to content

8. Hilos de ejecución

Este capítulo presenta la ejecución simultánea de varios fragmentos de código dentro de un mismo programa: los hilos (threads, o hilos de ejecución) y las herramientas para sincronizarlos. Hace unos veinte años, la mayoría de las máquinas tenían un solo procesador, y el paralelismo era en gran medida una ilusión mantenida por el sistema operativo. Hoy, incluso la computadora portátil más básica tiene varios núcleos: varios hilos se ejecutan realmente al mismo tiempo, lo que hace aún más frecuentes los problemas de sincronización que se tratan aquí.

Java admite hilos desde su primera versión (1996): la clase [Thread], la palabra clave [synchronized] y los métodos [wait] / [notify] de la clase [Object]. Java 5 (2004) agregó el paquete [java.util.concurrent] y sus subpaquetes [java.util.concurrent.locks] y [java.util.concurrent.atomic]: bloqueos (locks), semáforos, colecciones concurrentes, grupos de hilos (thread pools), etc. Java 7 agregó el framework [Fork/Join], Java 8 introdujo los streams paralelos y Java 21 introdujo los hilos virtuales, todo lo cual ha cambiado profundamente la forma de escribir servidores. Por último, Java 25 introduce los valores acotados a un ámbito ([ScopedValue]). Exploraremos todas estas herramientas en este capítulo.

Los ejemplos son archivos fuente compactos ([java Threads01.java]) ubicados en la carpeta [08-threads]. Recuerde que un archivo fuente compacto importa automáticamente todo el módulo [java.base]: por lo tanto, las clases de los paquetes [java.util.concurrent], [java.util.concurrent.locks], [java.util.concurrent.atomic] y [java.time] pueden usarse sin la directiva [import].

Una advertencia antes de empezar: los resultados de un programa multihilo varían de una ejecución a otra. El orden en que se asigna el procesador a los hilos depende del sistema operativo, del número de procesadores y de la carga de la máquina. Los resultados mostrados en este capítulo se obtuvieron en una máquina Linux de dos procesadores compartida con otros programas muy activos. Si usted ejecuta los ejemplos, obtendrá resultados similares, pero rara vez idénticos. Indicaremos en cada caso qué es reproducible y qué no.

8.1. La clase Thread

Cuando se inicia una aplicación, esta se ejecuta en un flujo de ejecución llamado hilo (thread). La clase de Java que modela un hilo es la clase [java.lang.Thread]. Sus principales constructores y métodos son los siguientes:

Miembro
Función
[Thread(Runnable task)], [Thread(Runnable task, String name)]
Crea un hilo que ejecutará el método [run] de [task]. [Runnable] es la interfaz funcional de [void run()]: lo más común es pasarle una lambda o una referencia a un método
[static Thread.Builder.OfPlatform ofPlatform()], [static Thread.Builder.OfVirtual ofVirtual()]
(Java 21) devuelven un constructor (builder) de hilos de plataforma o de hilos virtuales, que se configura (nombre, daemon, etc.) antes de crear el hilo
[static Thread currentThread()]
el hilo que ejecuta el código que llamó a este método
[String getName()], [void setName(String name)]
el nombre del hilo, útil para el seguimiento
[long threadId()]
(Java 19) un identificador numérico único del hilo; reemplaza a [getId()], que está obsoleto
[boolean isDaemon()], [void setDaemon(boolean b)]
Indica (y fija) si el hilo es un hilo daemon (véase más adelante)
[int getPriority()], [void setPriority(int p)]
la prioridad del hilo, de 1 ([MIN_PRIORITY]) a 10 ([MAX_PRIORITY]), con 5 ([NORM_PRIORITY]) como valor predeterminado
[Thread.State getState()], [boolean isAlive()]
el estado del hilo ([NEW], [RUNNABLE], [BLOCKED], [WAITING], [TIMED_WAITING], [TERMINATED]); [isAlive] indica si se ha iniciado pero no ha terminado
[boolean isVirtual()]
(Java 21) indica si el hilo es un hilo virtual
[void start()]
inicia la ejecución del hilo
[void join()], [boolean join(Duration timeout)]
El hilo T1, que ejecuta [T2.join()], se bloquea hasta que el hilo T2 haya terminado. La segunda forma (Java 19) limita el tiempo de espera e indica si T2 ha terminado
[static void sleep(long ms)], [static void sleep(Duration d)]
el hilo que ejecuta el método se suspende durante [ms] milisegundos (durante la duración [d]). Pierde la CPU, que se cede a otro hilo
[void interrupt()], [boolean isInterrupted()]
solicita al hilo que se detenga; verifica si se ha solicitado una detención (véase más adelante)

Los métodos [join] y [sleep] lanzan la excepción verificada [InterruptedException] si el hilo es interrumpido durante la espera: el compilador exige que se maneje o se declare. Hablaremos de su significado en la sección sobre interrupciones.

La clase [Thread] también tiene un método, [stop], que antes terminaba un hilo por la fuerza. Está obsoleto desde Java 1.2 y, desde Java 20, simplemente lanza la excepción [UnsupportedOperationException]: detener un hilo de forma abrupta podría dejar los datos que estaba manejando en un estado inconsistente. Hoy, se le pide a un hilo que se detenga de forma cooperativa mediante interrupción: lo veremos un poco más adelante.

Aquí hay una primera aplicación que demuestra la existencia de un hilo de ejecución principal, el que ejecuta el método [main]. El programa [Threads01.java] es el siguiente:

// el hilo principal de un programa

void main() throws InterruptedException {
    // el hilo que ejecuta este código
    Thread main = Thread.currentThread();
    // el lanzador de Java le asignó un nombre
    IO.println("Name of the current thread: [" + main.getName() + "]");
    // podemos cambiarlo
    main.setName("Main");
    IO.println("Name of the current thread: [" + main.getName() + "]");
    // algunas propiedades
    IO.println("Identifier (threadId): " + main.threadId());
    IO.println("Daemon thread (isDaemon): " + main.isDaemon());
    IO.println("Virtual thread (isVirtual): " + main.isVirtual());
    IO.println("Priority (getPriority): " + main.getPriority());
    IO.println("State (getState): " + main.getState());
    IO.println("Text representation: " + main);
    IO.println("Number of processors: " + Runtime.getRuntime().availableProcessors());

    // una visualización cada segundo
    var format = DateTimeFormatter.ofPattern("HH:mm:ss");
    for (int i = 0; i < 5; i++) {
        IO.println(main.getName() + " : " + LocalTime.now().format(format));
        // el hilo se suspende durante 1 segundo
        Thread.sleep(1000);
    }
}

Resultados:

> java Threads01.java
Name of the current thread: [main]
Name of the current thread: [Main]
Identifier (threadId): 3
Daemon thread (isDaemon): false
Virtual thread (isVirtual): false
Priority (getPriority): 5
State (getState): RUNNABLE
Text representation: Thread[#3,Main,5,main]
Number of processors: 2
Main : 19:14:06
Main : 19:14:07
Main : 19:14:08
Main : 19:14:09
Main : 19:14:10

Comentarios:

  • línea 5: se obtiene una referencia al hilo que ejecuta el programa;
  • líneas 7–10: mostramos su nombre, lo modificamos y lo mostramos de nuevo. Inicialmente, el hilo principal se llama [main] (línea 2 de los resultados): el lanzador de Java (launcher) le asignó este nombre;
  • Líneas 12–18: algunas propiedades del hilo. En esta ejecución, el hilo principal tiene el ID 3: la máquina virtual crea algunos hilos para sus propios fines antes de ejecutar [main], y este ID puede variar de una versión de Java a otra. No es un hilo daemon ([isDaemon()] es igual a [false]) ni un hilo virtual (hablaremos de estos dos conceptos más adelante); su prioridad es la prioridad normal de 5; se está ejecutando actualmente ([RUNNABLE]). El método [toString] del hilo (línea 17) muestra su ID, su nombre, su prioridad y el nombre de su grupo de hilos ([main]);
  • línea 18: la máquina que ejecutó el ejemplo tiene 2 procesadores;
  • líneas 21–26: un bucle que muestra una salida cada segundo. [Thread.sleep(1000)] suspende el hilo principal durante un segundo. Dado que [sleep] puede lanzar la excepción verificada [InterruptedException], el método [main] la declara en su cláusula [throws] (línea 3). Observe el formato [HH:mm:ss] (horas de 0 a 23): el formato [hh] mostraría las horas de 1 a 12.

8.2. Creación de hilos de ejecución

Es posible tener aplicaciones en las que fragmentos de código se ejecutan «simultáneamente» en distintos hilos de ejecución. Si la máquina tiene menos procesadores que hilos listos para ejecutarse, los hilos se reparten los procesadores: cada uno accede a un procesador por turnos durante un breve instante (unos pocos milisegundos). En una máquina multiprocesador, varios hilos se ejecutan realmente al mismo tiempo. El tiempo asignado a un hilo depende de varios factores, entre ellos su prioridad, que tiene un valor predeterminado pero puede establecerse mediante programación ([setPriority]); esto es solo una indicación, que el sistema operativo es libre de ignorar (Linux la ignora de forma predeterminada). Un hilo que tiene acceso al procesador puede liberarlo antes de tiempo:

  • esperando un evento (la finalización de otro hilo mediante [join], la espera de una señal);
  • durmiendo durante un período determinado ([sleep]).

Un hilo T se crea primero, por ejemplo, mediante el constructor [new Thread(task, name)], donde [task] es un objeto que implementa la interfaz funcional [Runnable], cuyo único método es [void run()]. Este objeto suele ser una lambda o una referencia a un método (las interfaces funcionales se introdujeron en el capítulo 7). En código más antiguo, también pueden encontrarse clases derivadas de *[Thread]* que redefinen su método *[run]*: esto no se recomienda, porque mezcla la tarea que se debe realizar con el medio para ejecutarla.

Crear un hilo no lo inicia:

  • la ejecución del hilo T se inicia mediante [T.start()]: el método [run] de la tarea pasada al constructor de T será entonces ejecutado por el hilo T. El código que ejecuta la instrucción [T.start()] no espera a que el hilo T termine: pasa de inmediato a la siguiente instrucción. Ahora tenemos dos hilos ejecutándose en paralelo. A menudo necesitan comunicarse entre sí para seguir el avance del trabajo compartido: este es el problema de la sincronización de hilos;
  • una vez iniciado, el hilo T se ejecuta de forma autónoma. Se detiene cuando el método que está ejecutando termina;
  • podemos esperar a que termine de ejecutarse mediante [T.join()]. Esta es una instrucción bloqueante: el hilo que la ejecuta se bloquea hasta que el hilo T haya terminado su trabajo. Este es un método básico de sincronización.

El programa [Threads02.java] es el siguiente:

// creación de hilos de ejecución

void main() {
    // se nombra el hilo principal
    Thread.currentThread().setName("Main");

    // creación de 5 hilos
    var tasks = new Thread[5];
    for (int i = 0; i < tasks.length; i++) {
        // el hilo n.º i ejecutará el método display; se le asigna el nombre "i"
        tasks[i] = new Thread(this::display, String.valueOf(i));
        // se inicia su ejecución (operación no bloqueante)
        tasks[i].start();
    }

    // fin del hilo principal
    IO.println("End of thread " + Thread.currentThread().getName() + " at " + time());
}

// el método ejecutado por los hilos: tiene la firma de Runnable.run()
void display() {
    // el hilo que ejecuta el método
    Thread current = Thread.currentThread();
    IO.println("Start of execution of the display method in thread " + current.getName()
            + " (id " + current.threadId() + ") : " + time());
    // espera de 1 s
    sleep(1000);
    IO.println("End of execution of the display method in thread " + current.getName()
            + " : " + time());
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        // la espera fue interrumpida: se restablece el indicador de interrupción del hilo
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 5: le damos un nombre al hilo principal;
  • líneas 8–14: se crean e inician 5 hilos. Sus referencias se almacenan en un arreglo para poder recuperarlas más tarde. Cada hilo ejecuta el método [display] de las líneas 21–30;
  • Línea 11: la referencia al método [this::display] se convierte automáticamente en un objeto [Runnable]: el método [display] no tiene parámetros y no devuelve ningún resultado, igual que [run]. Escribimos [this::display] porque, en un archivo fuente compacto, los métodos declarados fuera de cualquier clase son métodos de instancia de la clase implícita, cuyo nombre no puede utilizarse en el código. El segundo parámetro del constructor es el nombre del hilo;
  • línea 13: se lanza el hilo n.º i. Esta operación no es bloqueante: el hilo n.º i se ejecuta en paralelo con el hilo principal que lo lanzó;
  • línea 17: el hilo principal llega al final del programa;
  • Líneas 21–30: el método [display] muestra el nombre y el ID del hilo que lo ejecuta, así como las horas de inicio y fin (al milisegundo) de la ejecución;
  • línea 27: todo hilo que ejecuta el método [display] se detiene durante 1 segundo. El procesador se cede entonces a otro hilo que espera el procesador. Al final de la pausa de 1 segundo, el hilo en pausa vuelve a ser elegible para obtener el procesador. Lo obtendrá cuando le llegue el turno;
  • líneas 33–40: el método [sleep] encapsula [Thread.sleep]. El método [run] de [Runnable] no declara ninguna excepción verificada: por lo tanto, el método [display] no puede dejar escapar la excepción [InterruptedException] lanzada por [sleep] . El método [sleep] la intercepta y restablece el indicador de interrupción del hilo (línea 38); explicaremos esta acción en la sección sobre interrupciones. Encontraremos este pequeño método en la mayoría de los programas de este capítulo;
  • líneas 43–45: el método [time] devuelve la hora actual en el formato [HH:mm:ss.SSS] ([SSS]: los milisegundos).

Resultados:

> java Threads02.java
Start of execution of the display method in thread 4 (id 26) : 19:14:13.727
Start of execution of the display method in thread 1 (id 23) : 19:14:13.728
Start of execution of the display method in thread 0 (id 22) : 19:14:13.729
Start of execution of the display method in thread 2 (id 24) : 19:14:13.732
End of thread Main at 19:14:13.725
Start of execution of the display method in thread 3 (id 25) : 19:14:13.732
End of execution of the display method in thread 2 : 19:14:14.744
End of execution of the display method in thread 3 : 19:14:14.746
End of execution of the display method in thread 1 : 19:14:14.746
End of execution of the display method in thread 4 : 19:14:14.747
End of execution of the display method in thread 0 : 19:14:14.747

Estos resultados son muy instructivos:

  • En primer lugar, vemos que lanzar un hilo no es bloqueante. El hilo principal lanzó 5 hilos y llegó al final del programa (línea 6) aunque el hilo 3 aún no había mostrado su primer mensaje;
  • el orden de ejecución de los hilos es impredecible: en esta ejecución, el hilo 4 mostró su mensaje de inicio antes que el hilo 0. Aquí el sistema operativo tiene 6 hilos y 2 procesadores; asigna los procesadores a estos hilos según sus propias reglas;
  • También observamos que el orden de las salidas no siempre sigue el orden de las horas mostradas: el hilo principal mostró su finalización a las 13.725, después de mensajes fechados de 13.727 a 13.732. La hora se calcula antes de la salida y, mientras tanto, otro hilo puede haber escrito en la consola. [IO.println] (como [System.out.println]) es seguro para hilos (thread-safe): dos líneas escritas por dos hilos no se mezclan, pero su orden no está garantizado;
  • los ID de los hilos creados (22 a 26) muestran que la máquina virtual ya había creado unos veinte hilos para sus propios fines (recolección de basura, compilador just-in-time, etc.);
  • cada hilo se detiene durante un segundo en [sleep] y luego termina la ejecución del método [display];
  • Por último, el programa no se detuvo cuando el hilo principal terminó su trabajo: la máquina virtual esperó a que los cinco hilos terminaran. Esto se debe a que estos hilos no son hilos daemon: la máquina virtual de Java se detiene cuando todos sus hilos no daemon han terminado.

A la inversa, un hilo puede declararse como hilo daemon mediante [setDaemon(true)] antes de lanzarlo. Los hilos daemon son hilos de servicio que no impiden que la máquina virtual se detenga: cuando termina el último hilo no daemon, se detienen. El programa [Threads03.java] es el siguiente:

// hilos daemon

void main() {
    // se nombra el hilo principal
    Thread.currentThread().setName("Main");

    // un constructor de hilos: hilos de plataforma, daemon, con nombres 0, 1, 2…
    Thread.Builder builder = Thread.ofPlatform().daemon().name("", 0);
    // creación e inicio de 5 hilos daemon
    for (int i = 0; i < 5; i++) {
        // start crea un hilo y lo inicia de inmediato
        builder.start(this::display);
    }

    // se da tiempo a los hilos para que arranquen
    sleep(100);
    // fin del hilo principal y, por tanto, del programa
    IO.println("End of thread " + Thread.currentThread().getName() + " at " + time());
}

// el método ejecutado por los hilos
void display() {
    Thread current = Thread.currentThread();
    IO.println("Start of execution of the display method in thread " + current.getName()
            + " : " + time());
    // espera de 1 s
    sleep(1000);
    IO.println("End of execution of the display method in thread " + current.getName()
            + " : " + time());
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • Línea 8: a partir de Java 21, el método [Thread.ofPlatform()] devuelve un constructor de hilos de tipo [Thread.Builder], que se configura mediante llamadas encadenadas: [daemon()] solicita hilos daemon; [name("", 0)] especifica que los hilos se nombren con un prefijo (en este caso, la cadena vacía) seguido de un número que comienza en 0 y aumenta en uno por cada hilo creado. Los hilos de plataforma son los hilos «clásicos» que hemos utilizado desde el comienzo de este capítulo, en oposición a los hilos virtuales que se tratan más adelante;
  • línea 12: el método [start(Runnable)] del constructor crea un hilo y lo inicia de inmediato. Su método [unstarted(Runnable)] crea un hilo sin iniciarlo;
  • línea 16: el hilo principal espera 100 ms para dar tiempo a que los hilos se inicien y luego termina.

Resultados:

1
2
3
4
5
> java Threads03.java
Start of execution of the display method in thread 1 : 19:14:17.388
Start of execution of the display method in thread 0 : 19:14:17.424
End of thread Main at 19:14:17.425
Start of execution of the display method in thread 3 : 19:14:17.366

Tres de los cinco hilos comenzaron su ejecución y luego el hilo principal terminó (línea 4). El hilo 3 había calculado la hora de su mensaje antes de que terminara el hilo principal, pero solo pudo mostrarlo después (línea 5), mientras la máquina virtual se estaba cerrando. Los hilos daemon fueron entonces terminados durante su pausa de un segundo: no se mostró ningún mensaje de finalización. Dos hilos ni siquiera tuvieron tiempo de mostrar sus mensajes de inicio: como la máquina estaba muy cargada, 100 ms no bastaron para que obtuvieran la CPU (otra ejecución dará un número distinto de mensajes de inicio, pero nunca mensajes de finalización). Se obtiene el mismo efecto al terminar [main] con [System.exit(0)], que cierra la máquina virtual y, por lo tanto, todos los hilos de la aplicación, sean daemon o no. Los hilos virtuales, de los que hablaremos más adelante, son siempre hilos daemon.

Si el hilo principal quiere esperar a que terminen los hilos que ha creado, utiliza el método [join]. El programa [Threads04.java] también demuestra otra forma de especificar el código que debe ejecutar un hilo: una lambda.

// espera del fin de un hilo con join - hilos creados con una lambda

void main() throws InterruptedException {
    // se nombra el hilo principal
    Thread.currentThread().setName("Main");

    // creación de 5 hilos
    var tasks = new Thread[5];
    for (int i = 0; i < tasks.length; i++) {
        // copia local de i: una lambda solo usa variables efectivamente finales
        int number = i;
        // el hilo ejecuta la lambda, que llama a display con parámetros tipados
        tasks[i] = new Thread(() -> display(number, 1000 + 100 * number), String.valueOf(i));
        tasks[i].start();
    }

    // se espera el fin de todos los hilos
    for (Thread task : tasks) {
        // el hilo principal queda bloqueado hasta el fin del hilo [task]
        task.join();
    }
    // fin del hilo principal
    IO.println("End of thread " + Thread.currentThread().getName() + " at " + time());
}

// el método ejecutado por los hilos
static void display(int number, long duration) {
    String name = Thread.currentThread().getName();
    IO.println("Start of execution of task " + number + " in thread " + name + " : " + time());
    // espera de [duration] milisegundos
    sleep(duration);
    IO.println("End of execution of task " + number + " in thread " + name + " : " + time());
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • Línea 13: el hilo ejecuta la lambda [() -> display(number, 1000 + 100 * number)]. Una lambda sin parámetros y sin valor de retorno es compatible con la interfaz [Runnable]. Esta sintaxis permite llamar a un método con parámetros tipados (en este caso, un [int] y un [long]), mientras que [run] no tiene ninguno;
  • Línea 11: la lambda utiliza una copia de la variable del bucle [i]. Esto es obligatorio: una lambda solo puede utilizar variables locales que sean efectivamente finales, es decir, que nunca se modifiquen después de la inicialización. La variable [i] es modificada por el bucle ([i++]): si la lambda la utilizara, el compilador rechazaría el programa («local variables referenced from a lambda expression must be final or effectively final»). La variable [number], declarada dentro del cuerpo del bucle, es, en cambio, una variable nueva en cada iteración y nunca se modifica. Esta regla protege contra un error frecuente: sin ella, un hilo que se inicia tarde podría leer el valor de [i] de una iteración posterior, o incluso el valor final 5;
  • Líneas 18–21: el hilo principal espera a cada uno de los hilos. Primero se bloquea esperando al hilo 0, luego al hilo 1, y así sucesivamente. Cuando sale del bucle, los 5 hilos que lanzó han terminado todos. Dado que [join] puede lanzar [InterruptedException], [main] lanza esta excepción (línea 3);
  • línea 31: la tarea n.º i duerme 1000 + 100 × i milisegundos, de modo que los hilos terminan en un orden conocido.

Resultados:

> java Threads04.java
Start of execution of task 1 in thread 1 : 19:14:21.035
Start of execution of task 2 in thread 2 : 19:14:21.035
Start of execution of task 3 in thread 3 : 19:14:21.035
Start of execution of task 4 in thread 4 : 19:14:21.032
Start of execution of task 0 in thread 0 : 19:14:21.035
End of execution of task 0 in thread 0 : 19:14:22.039
End of execution of task 1 in thread 1 : 19:14:22.140
End of execution of task 2 in thread 2 : 19:14:22.239
End of execution of task 3 in thread 3 : 19:14:22.360
End of execution of task 4 in thread 4 : 19:14:22.440
End of thread Main at 19:14:22.440

Los mensajes de inicio aparecen en cualquier orden, pero los mensajes de finalización aparecen en orden numérico, ya que las duraciones de la pausa son crecientes: esta parte del resultado es reproducible. La última línea muestra que el hilo principal terminó después de los hilos que había lanzado, en el momento en que terminó el último de ellos.

8.3. Detener un hilo: la interrupción

¿Cómo se detiene un hilo antes de que termine su trabajo, por ejemplo, cuando el usuario cancela una operación larga? Java no permite matar un hilo; en su lugar, ofrece un mecanismo cooperativo llamado interrupción:

  • Cada hilo tiene un indicador de interrupción, un booleano inicialmente establecido en [false];
  • un hilo T1 que quiere detener al hilo T2 llama a [T2.interrupt()]. Esto activa el indicador de interrupción de T2. Se trata de una solicitud de terminación: T2 no es terminado; corresponde a ese hilo decidir cuándo y cómo terminar, de modo que deje sus datos en un estado consistente;
  • si T2 está bloqueado en un método de espera ([sleep], [join], [wait] y la mayoría de los métodos bloqueantes de [java.util.concurrent]), se lo despierta: el método lanza la excepción [InterruptedException] y el indicador de interrupción se restablece a [false];
  • si T2 realiza un cálculo sin esperar nunca, debe verificar su propio indicador mediante [Thread.currentThread().isInterrupted()] a intervalos regulares.

Por eso los métodos bloqueantes declaran la excepción verificada [InterruptedException]: el compilador exige que el programador decida qué hacer con una solicitud de detención. Hay dos respuestas correctas: dejar que la excepción se propague al llamador (declarándola en la cláusula [throws]), o interceptarla y completar la tarea de forma limpia. Cuando ninguna de las dos opciones es posible, como en el método [sleep] del programa anterior, el indicador se restablece mediante [Thread.currentThread().interrupt()] para que el código llamador aún pueda ver la solicitud. La única respuesta incorrecta es ignorar la excepción. El programa [Threads05.java] demuestra los tres casos:

// detención de un hilo: la interrupción

void main() throws InterruptedException {
    // 1 - un hilo que duerme la mayor parte del tiempo
    Thread sleeper = Thread.ofPlatform().name("sleeper").start(() -> {
        int round = 0;
        try {
            while (true) {
                round++;
                IO.println(time() + " : sleeper, round " + round);
                // sleep lanza InterruptedException si el hilo es interrumpido mientras duerme
                Thread.sleep(400);
            }
        } catch (InterruptedException e) {
            // la interrupción es una solicitud de detención: el hilo termina su trabajo de forma limpia
            IO.println(time() + " : sleeper interrupted while sleeping, it stops");
        }
    });
    // 2 - un hilo que calcula sin dormir nunca
    Thread calculator = Thread.ofPlatform().name("calculator").start(() -> {
        long n = 0;
        // el hilo comprueba regularmente su indicador de interrupción
        while (!Thread.currentThread().isInterrupted()) {
            n++;
        }
        IO.println(time() + " : calculator interrupted after %,d iterations, it stops".formatted(n));
    });
    // 3 - un hilo que ignora las interrupciones (no se debe imitar)
    Thread deaf = Thread.ofPlatform().name("deaf").daemon().start(() -> {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                // la excepción se "traga": la solicitud de detención se pierde
                IO.println(time() + " : deaf ignores the interruption and continues");
            }
        }
    });

    // se deja trabajar a los hilos durante 1 s
    Thread.sleep(1000);
    IO.println(time() + " : Main requests the three threads to stop");
    sleeper.interrupt();
    calculator.interrupt();
    deaf.interrupt();
    // espera del fin de cada hilo, como máximo 1 s
    for (Thread thread : List.of(sleeper, calculator, deaf)) {
        boolean finished = thread.join(Duration.ofSeconds(1));
        IO.println(time() + " : thread " + thread.getName() + " finished: " + finished);
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • Líneas 5–18: el hilo [sleeper] pasa la mayor parte del tiempo en [Thread.sleep]. El bucle [while (true)] no tiene condición de salida: es la excepción [InterruptedException], lanzada por [sleep] cuando se interrumpe el hilo, la que provoca la salida del bucle (línea 14). La lambda es una instrucción [try] que abarca todo el trabajo del hilo: al recibir la excepción, el hilo muestra un mensaje y luego termina;
  • líneas 20–27: el hilo [calculator] nunca espera. Verifica su indicador de interrupción en cada iteración del bucle (línea 23);
  • Líneas 29–38: el hilo [deaf] intercepta [InterruptedException] y continúa como si nada hubiera pasado. La solicitud de detención se pierde: este es el error que hay que evitar. Es un hilo daemon, para que el programa pueda terminar sin esperarlo;
  • Línea 41: el hilo principal deja que los demás hilos se ejecuten durante un segundo;
  • líneas 43–45: solicita que los tres hilos terminen;
  • líneas 47–50: espera a que cada hilo termine durante un segundo como máximo. El método [join(Duration)] (Java 19) devuelve [true] si el hilo ha terminado dentro de ese tiempo, y [false] en caso contrario. [Duration.ofSeconds(1)] representa una duración de un segundo (clase [java.time.Duration]).

Resultados:

> java Threads05.java
19:14:25.674 : sleeper, round 1
19:14:26.228 : sleeper, round 2
19:14:26.605 : Main requests the three threads to stop
19:14:26.606 : deaf ignores the interruption and continues
19:14:26.615 : sleeper interrupted while sleeping, it stops
19:14:26.622 : thread sleeper finished: true
19:14:26.642 : calculator interrupted after 37,667,665 iterations, it stops
19:14:26.742 : thread calculator finished: true
19:14:27.756 : thread deaf finished: false

Los hilos [sleeper] y [calculator] terminaron unos milisegundos después de la solicitud; el hilo [deaf] ignoró la solicitud y aún no había terminado un segundo después ([false], última línea). El número de iteraciones del calculador varía mucho de una ejecución a otra, según la parte de tiempo de CPU que haya recibido; el resto del resultado es reproducible.

La interrupción es el mecanismo que detiene todo en la biblioteca de Java: veremos más adelante que el método [cancel] de una tarea ([Future]) y la terminación abrupta de un grupo de hilos ([shutdownNow]) interrumpen los hilos afectados. El próximo capítulo presentará otras formas de cancelar el procesamiento asíncrono, como los tiempos de espera (timeouts).

8.4. Hilos virtuales

Los hilos que hemos creado hasta ahora son hilos de plataforma: cada uno es un envoltorio de un hilo del sistema operativo, que ocupa durante toda su vida útil. Un hilo del sistema es un recurso costoso: crearlo lleva tiempo, su pila reserva memoria (del orden de un megabyte) y el sistema no puede administrar eficientemente más que unos pocos miles de ellos. Sin embargo, un servidor que dedica un hilo a cada cliente (véase el diagrama del párrafo siguiente) pasa la mayor parte del tiempo esperando: la respuesta de una base de datos, la siguiente solicitud del cliente… Durante estas esperas, el hilo del sistema permanece bloqueado e inutilizable.

Java 21 introdujo los hilos virtuales («virtual threads», JEP 444). Un hilo virtual es un objeto [Thread] como cualquier otro, pero lo administra la máquina virtual de Java en lugar del sistema operativo:

  • para ejecutarse, un hilo virtual se monta sobre un hilo de plataforma, llamado su «hilo portador» (carrier thread). Los hilos portadores forman un grupo pequeño, cuyo tamaño predeterminado es el número de procesadores;
  • cuando un hilo virtual se bloquea ([sleep], espera de E/S de red, un bloqueo, una cola bloqueante, etc.), se desmonta: su pila se aparta en la memoria de la máquina virtual y el hilo portador queda disponible de inmediato para otro hilo virtual. Cuando termina la espera, el hilo virtual se vuelve a asociar a un hilo anfitrión, no necesariamente el mismo;
  • un hilo virtual ocupa unos cientos de bytes: se pueden crear millones.

El programa [Threads06.java] compara el lanzamiento de 10 000 hilos de plataforma y 10 000 hilos virtuales, cada uno de los cuales duerme durante un segundo:

// hilos de plataforma e hilos virtuales (Java 21)

void main() throws InterruptedException {
    final int nbThreads = 10_000;
    // dos constructores de hilos
    measure("platform threads", Thread.ofPlatform(), nbThreads);
    measure("virtual threads", Thread.ofVirtual(), nbThreads);

    // un hilo virtual se ejecuta sobre un hilo de plataforma llamado hilo portador (carrier thread)
    Thread virtual = Thread.ofVirtual().name("virtual").start(() -> {
        IO.println("Before sleep: " + Thread.currentThread());
        sleep(100);
        IO.println("After sleep: " + Thread.currentThread());
    });
    virtual.join();
    IO.println("isVirtual: " + virtual.isVirtual() + ", isDaemon: " + virtual.isDaemon());
}

// inicia [nbThreads] hilos que duermen 1 s, espera su fin y muestra la duración total
static void measure(String kind, Thread.Builder builder, int nbThreads) throws InterruptedException {
    long start = System.nanoTime();
    var threads = new ArrayList<Thread>(nbThreads);
    for (int i = 0; i < nbThreads; i++) {
        threads.add(builder.start(() -> sleep(1000)));
    }
    for (Thread thread : threads) {
        thread.join();
    }
    long duration = (System.nanoTime() - start) / 1_000_000;
    IO.println("%,d %s slept 1 s each: total duration %,d ms".formatted(nbThreads, kind, duration));
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

Comentarios:

  • líneas 6–7: el método [measure] se llama dos veces, primero con un constructor de hilos de plataforma ([Thread.ofPlatform()]) y luego con un constructor de hilos virtuales ([Thread.ofVirtual()]). Ambos constructores comparten el tipo común [Thread.Builder]: el resto del código es idéntico;
  • líneas 20–31: el método [measure] lanza [nbThreads] hilos que duermen durante un segundo, espera a que terminen y muestra la duración total. El método [System.nanoTime()] devuelve una hora en nanosegundos, que se utiliza únicamente para medir duraciones;
  • líneas 10–14: un hilo virtual llamado [virtual] muestra su representación textual antes y después de una pausa;
  • línea 16: un hilo virtual es siempre un hilo daemon.

Resultados:

1
2
3
4
5
6
> java Threads06.java
10,000 platform threads slept 1 s each: total duration 4,518 ms
10,000 virtual threads slept 1 s each: total duration 1,222 ms
Before sleep: VirtualThread[#20026,virtual]/runnable@ForkJoinPool-1-worker-2
After sleep: VirtualThread[#20026,virtual]/runnable@ForkJoinPool-1-worker-2
isVirtual: true, isDaemon: true
  • 10 000 hilos de plataforma tardaron varios segundos en hacer lo que debería haber tomado un segundo: crear los hilos del sistema y administrar sus pilas tuvo un costo elevado. Con 100 000 hilos, el programa probablemente fallaría por falta de memoria o de hilos del sistema disponibles;
  • 10 000 hilos virtuales completaron la misma tarea en poco más de un segundo: mientras dormían, no ocuparon ningún hilo del sistema. Los tiempos exactos varían de una ejecución a otra, pero la diferencia entre los dos tipos de hilos es reproducible;
  • la representación textual de un hilo virtual ([VirtualThread[#…,virtual]]) indica, después del carácter [@], el hilo anfitrión sobre el que está montado: un hilo del grupo [ForkJoinPool-1], al que volveremos más adelante. Tras ser suspendido, el hilo virtual puede reanudar su ejecución en otro portador.

Los hilos virtuales no hacen más rápidos los cálculos: un cálculo que mantiene ocupado el procesador sin esperar nunca no se ejecuta más rápido en un hilo virtual que en un hilo de plataforma, y el número de cálculos concurrentes sigue limitado por el número de procesadores. Su beneficio reside en la posibilidad de dedicar, sin preocuparse por el costo, un hilo a cada tarea que pasa la mayor parte del tiempo esperando: este es el caso de los servidores, del párrafo siguiente y de los capítulos 12 y 13. Todo lo que veremos sobre la sincronización de hilos se aplica por igual a los hilos virtuales y a los hilos de plataforma.

8.5. Beneficios de los hilos

Ahora que hemos puesto de relieve la existencia de un hilo predeterminado (el que ejecuta el método [main]) y que sabemos cómo crear otros, consideremos los beneficios de los hilos. Tienen dos usos principales:

  • aprovechar todos los procesadores de la máquina para un cálculo que consume mucho tiempo: el trabajo se divide en partes asignadas a distintos hilos. Lo haremos mediante streams paralelos y el framework [Fork/Join] al final de este capítulo;
  • realizar varias tareas simultáneamente, en particular cuando algunas de ellas consisten principalmente en esperar (una respuesta de red, una lectura de disco o una entrada del usuario). Este es el caso de las aplicaciones cliente/servidor de Internet, que trataremos en el capítulo 12.

En una aplicación cliente-servidor de Internet, un servidor ubicado en una máquina S1 responde a las solicitudes de clientes ubicados en máquinas remotas C1, C2, …, Cn:

Image

Utilizamos todos los días aplicaciones de Internet que siguen este esquema: servicios web, correo electrónico, transferencias de archivos, etc. En el diagrama anterior, el servidor S1 debe atender simultáneamente a los clientes Ci. Si tomamos el ejemplo de un servidor de archivos, sabemos que una transferencia puede durar a veces varios minutos. Es impensable que un solo cliente monopolice el servidor durante un período tan largo. Una solución habitual es que el servidor cree tantos hilos de ejecución como clientes haya. Cada hilo se encarga entonces de atender a un cliente específico:

Image

Con hilos de plataforma, el servidor utiliza en la práctica un grupo de hilos (thread pool, que veremos más adelante), cuyo número limitado de hilos fija un tope al número de clientes atendidos simultáneamente. Con hilos virtuales, el esquema anterior vuelve a ser la solución correcta: un hilo virtual por cliente, incluso si hay decenas de miles de clientes, ya que un cliente que está esperando no ocupa ningún hilo del sistema. Esto es lo que permiten hoy los servidores web modernos de Java, como Tomcat, que utilizaremos en el capítulo 13.

8.6. Intercambio de información entre hilos

En los ejemplos anteriores, los hilos ejecutaban un método sin parámetros, o una lambda que llamaba a un método con parámetros. Dado que el método *[run]* de [Runnable] no tiene parámetros ni valor de retorno, es la lambda la que transmite información al hilo lanzado: ella captura las variables que necesita. Si la variable capturada hace referencia a un objeto, el hilo lanzado también puede almacenar en él resultados que el hilo lanzador leerá. El programa [Threads07.java] es el siguiente:

// intercambio de información entre hilos

void main() throws InterruptedException {
    // se nombra el hilo principal
    Thread.currentThread().setName("Main");

    // creación de 5 hilos
    var tasks = new Thread[5];
    var data = new Data[5];
    for (int i = 0; i < tasks.length; i++) {
        // el objeto intercambiado con el hilo: el hilo que lanza establece el inicio y la duración
        Data d = new Data(LocalTime.now(), i + 1);
        data[i] = d;
        // el hilo lanzado recibe el objeto a través de la lambda que lo captura
        tasks[i] = new Thread(() -> sleep(d), String.valueOf(i));
        tasks[i].start();
    }

    // se espera a los hilos uno tras otro
    var format = DateTimeFormatter.ofPattern("HH:mm:ss");
    for (int i = 0; i < tasks.length; i++) {
        // espera del fin del hilo n.º i
        tasks[i].join();
        // el hilo n.º i ha rellenado la hora de fin de su objeto
        Data d = data[i];
        double actualDuration = Duration.between(d.getStart(), d.getEnd()).toMillis() / 1000.0;
        IO.println("Thread %s finished: start %s, scheduled duration %d s, end %s, actual duration %.3f s"
                .formatted(tasks[i].getName(), d.getStart().format(format), d.getDuration(),
                        d.getEnd().format(format), actualDuration));
    }
    // fin del hilo principal
    IO.println("End of thread " + Thread.currentThread().getName() + " at " + LocalTime.now().format(format));
}

// el método ejecutado por los hilos
static void sleep(Data data) {
    try {
        // espera de [duration] segundos
        Thread.sleep(data.getDuration() * 1000L);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    // el hilo lanzado devuelve un resultado al hilo que lo lanzó
    data.setEnd(LocalTime.now());
}

// la información intercambiada entre el hilo lanzador y el hilo lanzado
static class Data {
    // establecido por el hilo lanzador
    private final LocalTime start;
    private final int duration;
    // establecido por el hilo lanzado
    private LocalTime end;

    Data(LocalTime start, int duration) {
        this.start = start;
        this.duration = duration;
    }

    LocalTime getStart() {
        return start;
    }

    int getDuration() {
        return duration;
    }

    LocalTime getEnd() {
        return end;
    }

    void setEnd(LocalTime end) {
        this.end = end;
    }
}

Comentarios:

  • líneas 48–75: la información intercambiada con cada hilo es un objeto [Data]. Hay un intercambio de información en ambos sentidos entre el hilo lanzador y el hilo lanzado. [start] y [duration] son campos [final]: el constructor los establece de una vez por todas:
    • [start]: la hora de inicio de la ejecución del hilo, establecida por el hilo lanzador;
    • [duration]: duración en segundos de la pausa del hilo lanzado, establecida por el hilo lanzador;
    • [end]: la hora de fin de la ejecución del hilo, establecida por el hilo lanzado;
  • línea 12: se crea un objeto [Data] y se almacena en el arreglo [data] (línea 13);
  • línea 15: la lambda [() -> sleep(d)] captura la variable [d], que es efectivamente final: el hilo lanzado ejecutará el método [sleep] de las líneas 36–45 con el objeto [d] como parámetro;
  • líneas 21–30: el hilo principal espera a que termine cada uno de los hilos que ha lanzado y luego recupera el objeto [data[i]] del hilo n.º i y muestra su contenido. La duración real se calcula mediante [Duration.between(d.getStart(), d.getEnd())];
  • línea 39: el campo [duration] del parámetro establece la duración de la pausa;
  • línea 44: se rellena el campo [end] del parámetro.

Resultados:

1
2
3
4
5
6
7
> java Threads07.java
Thread 0 finished: start 19:14:38, scheduled duration 1 s, end 19:14:39, actual duration 1.005 s
Thread 1 finished: start 19:14:38, scheduled duration 2 s, end 19:14:40, actual duration 2.006 s
Thread 2 finished: start 19:14:38, scheduled duration 3 s, end 19:14:41, actual duration 3.000 s
Thread 3 finished: start 19:14:38, scheduled duration 4 s, end 19:14:42, actual duration 4.000 s
Thread 4 finished: start 19:14:38, scheduled duration 5 s, end 19:14:43, actual duration 5.000 s
End of thread Main at 19:14:43

Este ejemplo muestra que dos hilos pueden intercambiar información:

  • el hilo llamador puede controlar la ejecución del hilo llamado proporcionándole información;
  • el hilo lanzado puede devolver resultados al hilo lanzador.

Para que el hilo llamador sepa cuándo están disponibles los resultados que espera, debe ser notificado cuando el hilo llamado haya terminado. Aquí, esperó a que el hilo terminara mediante el método [join]. No es solo una cuestión de sincronización temporal: como veremos en la sección sobre la palabra clave [volatile], una escritura realizada por un hilo no es necesariamente visible para otro. El modelo de memoria de Java garantiza que todo lo que escribe un hilo es visible para el hilo que esperó su finalización mediante [join], y que todo lo que escribe el hilo lanzador antes de [start] es visible para el hilo lanzado. Más adelante exploraremos otras formas de sincronizar.

En lugar de una lambda, podríamos escribir una clase que implemente [Runnable] y cuyos campos contengan la información intercambiada. La lambda es más concisa; es el enfoque más común hoy en día. Para recuperar el resultado de un procesamiento, también veremos más adelante la interfaz [Callable<V>], cuyo método [V call()] devuelve un resultado.

8.7. Acceso concurrente a recursos compartidos

8.7.1. Acceso concurrente sin sincronización

En la sección anterior, la información se intercambiaba solo entre dos hilos y en momentos muy específicos: era un ejemplo clásico de paso de parámetros. Hay otros casos en los que la información es compartida por varios hilos que pueden querer leerla o actualizarla al mismo tiempo. Esto plantea el problema de la integridad de esta información. Supongamos que la información compartida es una estructura S que contiene diversos datos I1, I2, …, In:

  • un hilo T1 comienza a actualizar la estructura S: modifica el campo I1 y es interrumpido antes de completar la actualización de toda la estructura S;
  • un hilo T2 que obtiene entonces el procesador lee la estructura S para tomar decisiones. Lee una estructura en un estado inestable: algunos campos están actualizados y otros no.

Esta situación se denomina acceso concurrente a un recurso compartido, en este caso la estructura S. A menudo es difícil de manejar. Consideremos el siguiente ejemplo para ilustrar los problemas que pueden surgir:

  • una aplicación generará n hilos, donde n se pasa como parámetro;
  • el recurso compartido es un contador que cada hilo generado debe incrementar;
  • al final de la aplicación, se muestra el valor del contador. Por lo tanto, debería ser igual a n.

El programa [Threads08.java] es el siguiente:

// acceso concurrente no sincronizado a un recurso compartido

void main(String[] args) throws InterruptedException {
    // comprobación del argumento: el número de hilos que se crearán
    final int nbMaxThreads = 100;
    int nbThreads = args.length == 1 ? integer(args[0]) : -1;
    if (nbThreads < 1 || nbThreads > nbMaxThreads) {
        System.err.println("syntax: java Threads08.java nbThreads"
                + " (nbThreads between 1 and " + nbMaxThreads + ")");
        System.exit(1);
    }

    // creación e inicio de los hilos
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++) {
        threads[i] = new Thread(Counter::increment, String.valueOf(i));
        threads[i].start();
    }
    // espera del fin de los hilos
    for (Thread thread : threads) {
        thread.join();
    }
    // visualización del contador
    IO.println("Number of threads generated: " + Counter.getValue());
}

// el entero contenido en [text], -1 si no es válido
static int integer(String text) {
    try {
        return Integer.parseInt(text);
    } catch (NumberFormatException e) {
        return -1;
    }
}

// el recurso compartido
static class Counter {
    // el contador de hilos, compartido por todos los hilos
    private static int value;

    static int getValue() {
        return value;
    }

    // el método ejecutado por cada hilo
    static void increment() {
        String name = Thread.currentThread().getName();
        // lectura del contador
        int v = value;
        IO.println("At " + time() + ", thread " + name + " read the counter value: " + v);
        // espera: el hilo pierde el procesador
        sleep(1000);
        // incremento del contador
        value = v + 1;
        IO.println("At " + time() + ", thread " + name + " wrote the counter value: "
                + value);
    }
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • Líneas 5–11: el número de hilos se pasa como argumento. El método [integer] (líneas 28–34) devuelve el entero contenido en una cadena, o -1 si la cadena no contiene ninguno; por lo tanto, la condición de la línea 7 rechaza tanto un argumento faltante o no válido como un número fuera del rango [1, 100]. En caso de error, el programa escribe un mensaje en la salida de error ([System.err]) y termina con el código de salida 1 ([System.exit(1)]);
  • línea 16: cada hilo ejecuta el método estático [increment] de la clase [Counter]. La referencia al método [Counter::increment] es válida aquí porque [Counter] es una clase con nombre;
  • líneas 37–58: el recurso compartido es el campo estático [value] de la clase [Counter]. El contador está encapsulado en una clase anidada estática, con el método [increment] ejecutado por cada hilo;
  • línea 49: se lee el contador;
  • línea 52: el hilo se detiene durante 1 segundo. Por lo tanto, pierde la CPU;
  • línea 54: se incrementa el contador.

La pausa de un segundo está ahí solo para obligar al hilo a perder la CPU entre la lectura y la escritura del contador. En la práctica, no hay garantía de que un hilo no sea interrumpido entre estos dos momentos y, en una máquina multiprocesador, dos hilos pueden incluso leer el contador exactamente al mismo tiempo. La pausa de un segundo simplemente sistematiza este riesgo.

Los argumentos del programa se colocan después del nombre del archivo fuente. Sin argumentos, se muestra un mensaje de error (el comando de shell de Linux ***[echo $?]*** muestra el código de salida del último programa ejecutado):

1
2
3
4
> java Threads08.java
syntax: java Threads08.java nbThreads (nbThreads between 1 and 100)
> echo $?
1

Con 5 hilos:

> java Threads08.java 5
At 19:14:46.240, thread 1 read the counter value: 0
At 19:14:46.244, thread 3 read the counter value: 0
At 19:14:46.246, thread 4 read the counter value: 0
At 19:14:46.247, thread 0 read the counter value: 0
At 19:14:46.237, thread 2 read the counter value: 0
At 19:14:47.244, thread 1 wrote the counter value: 1
At 19:14:47.245, thread 3 wrote the counter value: 1
At 19:14:47.247, thread 4 wrote the counter value: 1
At 19:14:47.247, thread 0 wrote the counter value: 1
At 19:14:47.252, thread 2 wrote the counter value: 1
Number of threads generated: 1

Al observar estos resultados, está claro lo que sucede:

  • Un primer hilo lee el contador. Encuentra 0. Se detiene durante 1 segundo y pierde así la CPU;
  • un segundo hilo también lee el valor del contador. Sigue siendo 0, ya que el hilo anterior aún no lo ha incrementado. También se detiene durante 1 segundo;
  • en menos de un segundo, los 5 hilos tienen tiempo de leer el valor 0;
  • al despertar, incrementan el valor 0 que leyeron y todos escriben el valor 1 en el contador, como confirma la última línea (línea 12). Este resultado incorrecto es reproducible: solo cambia el orden de los hilos de una ejecución a otra.

Se podría objetar que el ejemplo es artificial. Así que eliminemos el sleep y utilicemos el operador [++], que da la ilusión de una sola instrucción. El programa [Threads09.java] es el siguiente:

// actualizaciones perdidas sin espera: counter++ no es atómico

void main(String[] args) throws InterruptedException {
    // parámetros: número de hilos, número de incrementos por hilo
    int nbThreads = args.length > 0 ? Integer.parseInt(args[0]) : 4;
    int nbIncrements = args.length > 1 ? Integer.parseInt(args[1]) : 50_000_000;

    // se repite el experimento tres veces
    for (int attempt = 1; attempt <= 3; attempt++) {
        Counter.value = 0;
        // creación e inicio de los hilos
        var threads = new Thread[nbThreads];
        for (int i = 0; i < nbThreads; i++) {
            threads[i] = Thread.ofPlatform().start(() -> {
                for (int j = 0; j < nbIncrements; j++) {
                    // leer, incrementar, escribir: tres operaciones
                    Counter.value++;
                }
            });
        }
        // espera del fin de los hilos
        for (Thread thread : threads) {
            thread.join();
        }
        // resultado
        int expected = nbThreads * nbIncrements;
        IO.println("Attempt %d: expected value %,d, obtained value %,d, lost updates %,d"
                .formatted(attempt, expected, Counter.value, expected - Counter.value));
    }
}

// el recurso compartido
static class Counter {
    static int value;
}

Comentarios:

  • líneas 5–6: el número de hilos (4 de forma predeterminada) y el número de incrementos que realiza cada hilo (50 millones de forma predeterminada) pueden pasarse como argumentos. El separador [_] hace legible la constante [50_000_000];
  • línea 14: los hilos se crean y se inician mediante [Thread.ofPlatform().start(…)]; no necesitan nombres;
  • Línea 17: cada hilo incrementa el contador compartido sin hacer pausas;
  • línea 27: en la cadena de formato, [%,d] muestra un entero con el separador de miles del idioma actual (en este caso, inglés: una coma). El método de instancia [formatted(…)] (Java 15) de una cadena equivale a [String.format(string, …)].

Resultados:

1
2
3
4
> java Threads09.java
Attempt 1: expected value 200,000,000, obtained value 132,308,591, lost updates 67,691,409
Attempt 2: expected value 200,000,000, obtained value 135,621,476, lost updates 64,378,524
Attempt 3: expected value 200,000,000, obtained value 50,000,635, lost updates 149,999,365

Se perdieron decenas de millones de actualizaciones, y la cantidad varía de una prueba a otra. La operación de alto nivel [Counter.value++] se traduce en realidad en varias instrucciones elementales del procesador: leer el valor de la memoria, incrementarlo en un registro y escribir el resultado en la memoria. Si dos hilos leen el mismo valor antes de que uno de ellos haya escrito el suyo, se pierde un incremento, exactamente como en el ejemplo anterior.

La prueba 3 merece una explicación: perdió casi exactamente 150 millones de actualizaciones, es decir, el trabajo de tres de los cuatro hilos. Tras unos segundos de ejecución, el compilador just-in-time (JIT) de la máquina virtual optimizó el bucle de las líneas 15–18: determinó que ningún otro hilo debía ver el contador durante el bucle (nada en el código lo exige) y colocó el contador en un registro del procesador. Cada hilo lee entonces el contador una sola vez, le suma 50 millones en su registro y lo vuelve a escribir una sola vez al final. Si los cuatro hilos leen el valor 0 antes de que alguno de ellos haya escrito, se pierden tres de los cuatro resultados; si, en cambio, su trabajo no se superpone, el resultado es correcto. En otras ejecuciones de este programa, las pruebas 2 y 3 dieron efectivamente el valor exacto de 200 000 000. Solo la primera prueba, ejecutada antes de esta optimización, pierde actualizaciones de manera constante. Eso es lo que hace tan peligrosos estos errores: un programa puede funcionar durante meses y fallar justo el día en que la máquina está más cargada o funciona más rápido.

¿De dónde proviene el problema? Un hilo leyó un valor desactualizado porque otro hilo había sido interrumpido (o trabajaba simultáneamente en otro procesador) antes de terminar su tarea de actualizar el contador. Esto nos lleva a los conceptos de recurso crítico y de sección crítica de un programa:

  • un recurso crítico es un recurso que solo puede ser poseído por un hilo a la vez. Aquí, el recurso crítico es el contador;
  • una sección crítica de un programa es una secuencia de instrucciones del flujo de ejecución de un hilo durante la cual este accede a un recurso crítico. Debemos asegurarnos de que, durante esta sección crítica, el hilo sea el único que tiene acceso al recurso.

En el programa [Threads08.java], la sección crítica es el código comprendido entre la lectura del contador y la escritura de su nuevo valor:

1
2
3
4
5
6
7
        // lectura del contador
        int v = value;
        IO.println("At " + time() + ", thread " + name + " read the counter value: " + v);
        // espera: el hilo pierde el procesador
        sleep(1000);
        // incremento del contador
        value = v + 1;

Para ejecutar este código, se debe garantizar que un hilo sea el único en ejecución. Puede ser interrumpido, pero durante esa interrupción ningún otro hilo debe poder ejecutar este mismo código. Java ofrece diversas herramientas para asegurar la entrada de un solo hilo a las secciones críticas de código. Veremos algunas de ellas a continuación.

8.7.2. La palabra clave synchronized

El bloque [synchronized] delimita una sección crítica de la siguiente manera: [synchronized (lock) { …critical section… }]***. [lock]* es un objeto visible para todos los hilos que ejecutan la sección crítica. En Java, todo objeto tiene un bloqueo interno, también conocido como monitor. El bloque [synchronized] garantiza que solo un hilo a la vez posea el monitor del objeto [lock], es decir, que solo un hilo a la vez ejecute la sección crítica: un hilo que encuentra un monitor poseído por otro hilo queda bloqueado hasta que el monitor se libera. El monitor se libera al salir del bloque, ya sea que la salida sea normal o se deba a una excepción.

El ejemplo anterior se reescribe de la siguiente manera en [Threads10.java]:

// sección crítica protegida por un bloque synchronized

void main(String[] args) throws InterruptedException {
    // comprobación del argumento: el número de hilos que se crearán
    final int nbMaxThreads = 100;
    int nbThreads = args.length == 1 ? integer(args[0]) : -1;
    if (nbThreads < 1 || nbThreads > nbMaxThreads) {
        System.err.println("syntax: java Threads10.java nbThreads"
                + " (nbThreads between 1 and " + nbMaxThreads + ")");
        System.exit(1);
    }

    // creación e inicio de los hilos
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++) {
        threads[i] = new Thread(Counter::increment, String.valueOf(i));
        threads[i].start();
    }
    // espera del fin de los hilos, en orden inverso al de su creación
    Thread.currentThread().setName("Main");
    for (int i = nbThreads - 1; i >= 0; i--) {
        IO.println("At " + time() + ", thread Main waits for the end of thread " + threads[i].getName());
        threads[i].join();
        IO.println("At " + time() + ", thread Main was notified of the end of thread "
                + threads[i].getName());
    }
    // visualización del contador
    IO.println("Number of threads generated: " + Counter.getValue());
}

// el entero contenido en [text], -1 si no es válido
static int integer(String text) {
    try {
        return Integer.parseInt(text);
    } catch (NumberFormatException e) {
        return -1;
    }
}

// el recurso compartido
static class Counter {
    // el contador de hilos
    private static int value;
    // el objeto de sincronización, visible para todos los hilos
    private static final Object lock = new Object();

    static int getValue() {
        synchronized (lock) {
            return value;
        }
    }

    // el método ejecutado por cada hilo
    static void increment() {
        String name = Thread.currentThread().getName();
        IO.println("At " + time() + ", thread " + name
                + " waits for permission to enter the critical section");
        // solo un hilo a la vez ejecuta el bloque siguiente
        synchronized (lock) {
            // lectura del contador
            int v = value;
            IO.println("At " + time() + ", thread " + name + " read the counter value: " + v);
            // espera: el hilo pierde el procesador pero conserva el bloqueo
            sleep(1000);
            // incremento del contador
            value = v + 1;
            IO.println("At " + time() + ", thread " + name + " wrote the counter value: "
                    + value);
        }
        IO.println("At " + time() + ", thread " + name + " left the critical section");
    }
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 45: [lock] es el objeto que permitirá sincronizar todos los hilos. No tiene ningún otro uso: es un simple [Object]. Es [final]: la referencia nunca debe cambiar, de lo contrario dos hilos podrían bloquear dos objetos distintos;
  • líneas 59–69: la sección crítica del método [increment] está encerrada en el bloque [synchronized]. El hilo conserva el bloqueo mientras duerme un segundo: los demás hilos no pueden entrar;
  • líneas 47–51: la lectura del contador por parte del hilo principal también está protegida por el bloqueo. Aquí no es estrictamente necesario, ya que el hilo principal esperó a que los otros hilos terminaran con [join]; pero es una buena práctica: los datos protegidos por un bloqueo deben leerse y escribirse bajo la protección de ese bloqueo;
  • Líneas 20–26: el hilo principal espera a los hilos en el orden inverso al de su creación.

Resultados con 3 hilos:

> java Threads10.java 3
At 19:14:50.140, thread 2 waits for permission to enter the critical section
At 19:14:50.147, thread 2 read the counter value: 0
At 19:14:50.140, thread 1 waits for permission to enter the critical section
At 19:14:50.140, thread 0 waits for permission to enter the critical section
At 19:14:50.133, thread Main waits for the end of thread 2
At 19:14:51.151, thread 2 wrote the counter value: 1
At 19:14:51.152, thread 1 read the counter value: 1
At 19:14:51.153, thread 2 left the critical section
At 19:14:51.153, thread Main was notified of the end of thread 2
At 19:14:51.153, thread Main waits for the end of thread 1
At 19:14:52.160, thread 1 wrote the counter value: 2
At 19:14:52.160, thread 0 read the counter value: 2
At 19:14:52.160, thread 1 left the critical section
At 19:14:52.162, thread Main was notified of the end of thread 1
At 19:14:52.162, thread Main waits for the end of thread 0
At 19:14:53.160, thread 0 wrote the counter value: 3
At 19:14:53.160, thread 0 left the critical section
At 19:14:53.161, thread Main was notified of the end of thread 0
Number of threads generated: 3
  • los tres hilos solicitan entrar en la sección crítica casi al mismo tiempo;
  • solo uno entra: en este caso, el hilo 2 (el orden de entrada no está garantizado: no necesariamente entra primero el primero en llegar). Lee el contador, duerme un segundo, escribe el nuevo valor y sale de la sección crítica;
  • los otros dos hilos quedan bloqueados hasta que el primero sale de la sección crítica y luego avanzan uno tras otro. Cada uno lee el valor escrito por el anterior. Observe (líneas 8–9) que Thread 1 leyó el contador antes de que Thread 2 indicara que había salido de la sección crítica: Thread 2 sí liberó el bloqueo, pero no muestra su mensaje hasta después del bloque [synchronized], y Thread 1 fue más rápido;
  • el hilo principal esperaba a que Thread 2 terminara. Al ser notificado de que Thread 2 había terminado, esperó a que terminara Thread 1 y luego Thread 0;
  • el valor final del contador es correcto (línea 20). Sea cual sea el orden en que se ejecuten los hilos, este resultado es reproducible.

La palabra clave [synchronized] también puede aplicarse a un método completo: [synchronized void m() {…}] equivale a un bloque [synchronized (this) {…}] que abarca todo el cuerpo del método, y [static synchronized void m() {…}] a un bloque [synchronized (Counter.class) {…}], que bloquea el objeto de clase [Class]. Es la notación más corta y se usa con frecuencia. Sin embargo, tiene un inconveniente: el objeto bloqueado ([this], o el objeto [Class]) es visible desde el exterior, y código externo puede adquirir el mismo bloqueo y bloquear el nuestro. Por eso suele ser preferible bloquear un objeto private, como en el ejemplo. Por la misma razón, nunca se bloquea una cadena (los literales de cadena idénticos son un único objeto compartido por todo el programa) ni, desde Java 16, un objeto de una clase “basada en valores” como [Integer] o [LocalDate] (el compilador emite una advertencia en ese caso).

Un hilo que ya posee un monitor puede volver a entrar en un bloque [synchronized] sobre el mismo objeto sin bloquearse a sí mismo: se dice que el bloqueo es reentrante. Un método [synchronized] puede así llamar a otro método [synchronized] del mismo objeto.

8.7.3. La clase ReentrantLock

El bloqueo [synchronized] es simple pero rígido: un hilo que espera un monitor espera indefinidamente, sin poder desistir tras cierto tiempo y sin poder ser interrumpido. La clase [java.util.concurrent.locks.ReentrantLock] (Java 5) es un bloqueo explícito, también reentrante, que ofrece estas capacidades. Implementa la interfaz [Lock]. Usaremos los siguientes constructores y métodos:

Miembro
Función
[ReentrantLock()], [ReentrantLock(boolean fair)]
crea un bloqueo. Un bloqueo justo ([true]) se concede a los hilos en el orden en que lo solicitaron; un bloqueo no justo (el valor predeterminado) es más rápido, pero un hilo puede adelantarse a otros
[void lock()]
El hilo T1, que ejecuta [V.lock()], solicita el bloqueo V. Si V no está en poder de ningún hilo, se concede a T1. Si un hilo T2 realiza entonces la misma operación, queda bloqueado: un bloqueo solo puede pertenecer a un hilo. T2 se desbloqueará cuando T1 libere V. Así, varios hilos pueden quedar bloqueados a la espera de V
[boolean tryLock()], [boolean tryLock(long timeout, TimeUnit unit)]
solicita el bloqueo de inmediato, o esperando como máximo [timeout]. El método devuelve [false] si no se pudo obtener el bloqueo
[void lockInterruptibly()]
como [lock], pero la espera puede ser interrumpida ([InterruptedException])
[void unlock()]
El hilo que posee V lo libera. Uno de los hilos que esperan V lo adquiere entonces
[boolean isHeldByCurrentThread()]
indica si el hilo actual posee el bloqueo
[Condition newCondition()]
crea una condición asociada al bloqueo (véase más adelante)

La sincronización de una sección crítica sigue siempre el mismo patrón: [V.lock(); try { …critical section… } finally { V.unlock(); }]. No olvide liberar el bloqueo; de lo contrario, los hilos que lo esperan permanecerán bloqueados indefinidamente: por eso el bloqueo se libera en una cláusula [finally], que se ejecuta haya ocurrido o no una excepción. El bloque [synchronized] lo hace automáticamente; con un [ReentrantLock], es responsabilidad del programador. El programa [Threads11.java] continúa el ejemplo anterior con un [ReentrantLock]:

// sección crítica protegida por un ReentrantLock

void main(String[] args) throws InterruptedException {
    // comprobación del argumento: el número de hilos que se crearán
    final int nbMaxThreads = 100;
    int nbThreads = args.length == 1 ? integer(args[0]) : -1;
    if (nbThreads < 1 || nbThreads > nbMaxThreads) {
        System.err.println("syntax: java Threads11.java nbThreads"
                + " (nbThreads between 1 and " + nbMaxThreads + ")");
        System.exit(1);
    }

    // creación e inicio de los hilos
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++) {
        threads[i] = new Thread(Counter::increment, String.valueOf(i));
        threads[i].start();
    }
    // espera del fin de los hilos
    for (Thread thread : threads) {
        thread.join();
    }
    // visualización del contador
    IO.println("Number of threads generated: " + Counter.getValue());
}

// el entero contenido en [text], -1 si no es válido
static int integer(String text) {
    try {
        return Integer.parseInt(text);
    } catch (NumberFormatException e) {
        return -1;
    }
}

// el recurso compartido
static class Counter {
    // el contador de hilos
    private static int value;
    // el objeto de sincronización: un bloqueo justo (true)
    private static final ReentrantLock lock = new ReentrantLock(true);

    static int getValue() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }

    // el método ejecutado por cada hilo
    static void increment() {
        String name = Thread.currentThread().getName();
        IO.println("At " + time() + ", thread " + name
                + " waits for permission to enter the critical section");
        // se solicita el bloqueo
        lock.lock();
        try {
            // lectura del contador
            int v = value;
            IO.println("At " + time() + ", thread " + name + " read the counter value: " + v);
            // espera
            sleep(1000);
            // incremento del contador
            value = v + 1;
            IO.println("At " + time() + ", thread " + name + " wrote the counter value: "
                    + value);
        } finally {
            // se libera el bloqueo, haya o no excepción
            IO.println("At " + time() + ", thread " + name + " leaves the critical section");
            lock.unlock();
        }
    }
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

El programa principal es el de [Threads08.java]. Comentarios:

  • línea 41: el objeto de sincronización de los hilos es ahora un bloqueo justo, [ReentrantLock];
  • línea 58: inicio de la sección crítica. El hilo queda bloqueado hasta que se libere el bloqueo;
  • líneas 59–73: como un bloqueo siempre debe liberarse, haya o no una excepción, la sección crítica se coloca dentro de un [try], cuya cláusula [finally] libera el bloqueo (línea 72);
  • Líneas 43–50: el mismo patrón protege la lectura del contador. La instrucción [return value;] se ejecuta antes de la cláusula [finally]: el valor devuelto se lee mientras se posee el bloqueo.

Resultados:

> java Threads11.java 3
At 19:14:55.022, thread 1 waits for permission to enter the critical section
At 19:14:55.025, thread 1 read the counter value: 0
At 19:14:55.020, thread 2 waits for permission to enter the critical section
At 19:14:55.020, thread 0 waits for permission to enter the critical section
At 19:14:56.027, thread 1 wrote the counter value: 1
At 19:14:56.027, thread 1 leaves the critical section
At 19:14:56.027, thread 2 read the counter value: 1
At 19:14:57.028, thread 2 wrote the counter value: 2
At 19:14:57.028, thread 2 leaves the critical section
At 19:14:57.028, thread 0 read the counter value: 2
At 19:14:58.028, thread 0 wrote the counter value: 3
At 19:14:58.028, thread 0 leaves the critical section
Number of threads generated: 3

Los resultados son similares a los anteriores: los hilos entran en la sección crítica uno por uno y el valor final del contador es correcto. Como el bloqueo es justo, los hilos lo adquirieron en el orden en que lo solicitaron: el orden de sus llamadas a [lock], que las marcas de tiempo del mensaje “esperando permiso”, calculadas un poco antes, solo aproximan.

¿Cuándo conviene usar [ReentrantLock] en lugar de [synchronized]? Cuando se necesita alguna de sus funciones adicionales: tiempo de espera máximo ([tryLock], que usaremos para evitar el interbloqueo), espera interrumpible, equidad o varias condiciones. En los demás casos, el bloque [synchronized], que es más simple y elimina el riesgo de olvidar [unlock], funciona muy bien. Desde Java 24 ya no causa ningún problema con los hilos virtuales: antes, un hilo virtual bloqueado en un bloque [synchronized] no podía liberar su hilo anfitrión, lo que hacía de [ReentrantLock] la opción preferida.

8.7.4. Sincronización de procesos: el bloqueo de archivo

Los bloqueos descritos hasta ahora sincronizan hilos dentro de una misma máquina virtual, es decir, dentro de un mismo proceso. A veces diferentes procesos necesitan compartir un recurso, como un archivo, o se desea impedir que se inicien dos instancias de una misma aplicación. Java no ofrece un objeto de sincronización con nombre compartido entre procesos; en su lugar se utiliza un bloqueo de archivo administrado por el sistema operativo: la clase [java.nio.channels.FileLock]. Se obtiene un bloqueo sobre un archivo abierto en forma de canal [FileChannel]:

  • [FileLock lock()]: espera a que el bloqueo esté disponible y lo adquiere;
  • [FileLock tryLock()]: intenta adquirir el bloqueo sin esperar y devuelve [null] si otro proceso lo posee;
  • [void release()]: libera el bloqueo. El bloqueo también se libera cuando se cierra el canal o cuando el proceso termina, incluso de forma abrupta: un bloqueo no puede quedar “abandonado”.

El programa [Threads12.java] se inicia dos veces, en dos procesos distintos, que comparten una sección crítica:

// un bloqueo de archivo sincroniza procesos distintos

void main(String[] args) throws IOException, InterruptedException {
    // el archivo bloqueado es conocido por todos los procesos que lo usan
    Path file = Path.of(System.getProperty("java.io.tmpdir"), "java-course-threads-12.lock");
    // el nombre del proceso se pasa como argumento
    String process = args.length > 0 ? args[0] : "P";

    // se abre el archivo (se crea si aún no existe)
    try (FileChannel channel = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
        IO.println(time() + " : process " + process + " requests the lock");
        // intento sin espera: null si otro proceso tiene el bloqueo
        FileLock lock = channel.tryLock();
        if (lock == null) {
            IO.println(time() + " : the lock is held by another process, " + process + " waits");
            // espera sin límite de tiempo
            lock = channel.lock();
        }
        try {
            // sección crítica entre procesos
            IO.println(time() + " : process " + process + " obtained the lock, it works for 3 s");
            Thread.sleep(3000);
            IO.println(time() + " : process " + process + " releases the lock");
        } finally {
            lock.release();
        }
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 5: el archivo que sirve como bloqueo. Todos los procesos que bloquean este archivo se sincronizan entre sí. Se ubica en la carpeta de archivos temporales del sistema, indicada por la propiedad del sistema [java.io.tmpdir] ([/tmp] en Linux). Su contenido es irrelevante: puede permanecer vacío;
  • línea 10: el archivo se abre para escritura (un bloqueo exclusivo lo requiere) y se crea si todavía no existe ([CREATE]). La instrucción [try] con recurso cerrará el canal al final;
  • línea 13: el proceso intenta adquirir el bloqueo sin esperar. Si falla, lo informa y luego espera el bloqueo indefinidamente (línea 17);
  • Líneas 19–26: la sección crítica, que dura 3 segundos, seguida de la liberación del bloqueo.

Un bloqueo de archivo pertenece al proceso completo, no a un hilo en particular: no sirve para sincronizar hilos dentro de un mismo proceso (dos solicitudes de bloqueo sobre el mismo archivo dentro del mismo proceso provocan la excepción [OverlappingFileLockException]). Iniciamos el proceso A, esperamos 1,5 segundos y luego iniciamos el proceso B en una segunda terminal. Resultados del proceso A:

1
2
3
4
> java Threads12.java A
19:15:04.965 : process A requests the lock
19:15:04.976 : process A obtained the lock, it works for 3 s
19:15:07.976 : process A releases the lock

Resultados del proceso B:

1
2
3
4
5
> java Threads12.java B
19:15:06.394 : process B requests the lock
19:15:06.405 : the lock is held by another process, B waits
19:15:07.977 : process B obtained the lock, it works for 3 s
19:15:10.978 : process B releases the lock

El proceso B encontró el bloqueo en poder del proceso A y esperó. Adquirió el bloqueo en el mismo instante en que A lo liberó. Un uso frecuente de este mecanismo es impedir el inicio de dos instancias de una misma aplicación: la segunda instancia, al no poder adquirir el bloqueo con [tryLock], termina de inmediato.

8.7.5. Una barrera: la clase Semaphore

Un semáforo es un contador de permisos (o plazas). La clase [java.util.concurrent.Semaphore] ofrece los siguientes métodos:

Miembro
Función
[Semaphore(int permits)], [Semaphore(int permits, boolean fair)]
crea un semáforo con [permits] permisos; el segundo parámetro tiene el mismo significado que en [ReentrantLock]
[void acquire()]
adquiere un permiso. Si no quedan permisos, el hilo queda bloqueado hasta que se libere uno. La espera puede ser interrumpida ([InterruptedException])
[void acquireUninterruptibly()]
igual que el anterior, pero la espera no puede ser interrumpida
[boolean tryAcquire()], [boolean tryAcquire(long timeout, TimeUnit unit)]
obtiene un permiso de inmediato, o como máximo dentro de [timeout]; devuelve [false] si el intento falla
[void release()]
devuelve (agrega) un permiso; uno de los hilos en espera puede entonces tomarlo
[int availablePermits()]
el número de permisos disponibles

A diferencia de un bloqueo, un permiso no pertenece a ningún hilo en particular: cualquier hilo puede llamar a [release], incluso si nunca ha adquirido un permiso. Un semáforo creado con cero permisos es, por lo tanto, una barrera cerrada, en la que los hilos que llaman a [acquire] quedan bloqueados. Otro hilo la abrirá cuando llegue el momento, llamando a [release]. Este momento depende por completo del problema que se resuelva. El hilo que adquirió el único permiso atravesó la barrera, que se cerró tras él; al devolver el permiso, abre la barrera para otro hilo. Si, en el ejemplo anterior, reemplazamos el bloqueo por una barrera de este tipo, el código queda así ([Threads13.java]):

// sección crítica protegida por una barrera: un semáforo con un único permiso

void main(String[] args) throws InterruptedException {
    // comprobación del argumento: el número de hilos que se crearán
    final int nbMaxThreads = 100;
    int nbThreads = args.length == 1 ? integer(args[0]) : -1;
    if (nbThreads < 1 || nbThreads > nbMaxThreads) {
        System.err.println("syntax: java Threads13.java nbThreads"
                + " (nbThreads between 1 and " + nbMaxThreads + ")");
        System.exit(1);
    }

    // creación e inicio de los hilos
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++) {
        threads[i] = new Thread(Counter::increment, String.valueOf(i));
        threads[i].start();
    }
    // se deja que los hilos lleguen ante la barrera cerrada
    Thread.sleep(500);
    // se abre la barrera de la sección crítica
    Thread.currentThread().setName("Main");
    IO.println("At " + time() + ", thread Main opens the barrier of the critical section");
    Counter.synchro.release();
    // espera del fin de los hilos
    for (Thread thread : threads) {
        thread.join();
    }
    // visualización del contador
    IO.println("Number of threads generated: " + Counter.getValue());
}

// el entero contenido en [text], -1 si no es válido
static int integer(String text) {
    try {
        return Integer.parseInt(text);
    } catch (NumberFormatException e) {
        return -1;
    }
}

// el recurso compartido
static class Counter {
    // el contador de hilos
    private static int value;
    // la barrera: un semáforo creado sin ningún permiso, por tanto cerrado
    static final Semaphore synchro = new Semaphore(0);

    static int getValue() {
        return value;
    }

    // el método ejecutado por cada hilo
    static void increment() {
        String name = Thread.currentThread().getName();
        IO.println("At " + time() + ", thread " + name
                + " waits for permission to enter the critical section");
        // paso de la barrera: el hilo toma el único permiso, la barrera se cierra tras él
        synchro.acquireUninterruptibly();
        try {
            // lectura del contador
            int v = value;
            IO.println("At " + time() + ", thread " + name + " read the counter value: " + v);
            // espera
            sleep(1000);
            // incremento del contador
            value = v + 1;
            IO.println("At " + time() + ", thread " + name + " wrote the counter value: "
                    + value);
        } finally {
            // se devuelve el permiso: la barrera se abre para otro hilo
            IO.println("At " + time() + ", thread " + name + " leaves the critical section");
            synchro.release();
        }
    }
}

Comentarios:

  • línea 47: la barrera se crea en estado cerrado. La abrirá el hilo principal en la línea 24;
  • línea 20: el hilo principal espera medio segundo para dar tiempo a que los hilos lleguen a la barrera;
  • línea 59: el hilo encargado de incrementar el contador solicita permiso para entrar en la sección crítica. Los distintos hilos se acumulan frente a la barrera cerrada. Cuando el hilo principal la abre, uno de los hilos en espera pasa y la barrera se cierra de nuevo. El método [acquireUninterruptibly] evita tener que manejar aquí la excepción [InterruptedException];
  • línea 73: cuando ha terminado su trabajo, el hilo vuelve a abrir la barrera, lo que permite entrar a otro hilo.

Resultados:

> java Threads13.java 3
At 19:15:00.034, thread 1 waits for permission to enter the critical section
At 19:15:00.048, thread 2 waits for permission to enter the critical section
At 19:15:00.041, thread 0 waits for permission to enter the critical section
At 19:15:00.532, thread Main opens the barrier of the critical section
At 19:15:00.533, thread 1 read the counter value: 0
At 19:15:01.535, thread 1 wrote the counter value: 1
At 19:15:01.535, thread 1 leaves the critical section
At 19:15:01.535, thread 2 read the counter value: 1
At 19:15:02.536, thread 2 wrote the counter value: 2
At 19:15:02.536, thread 2 leaves the critical section
At 19:15:02.536, thread 0 read the counter value: 2
At 19:15:03.536, thread 0 wrote the counter value: 3
At 19:15:03.536, thread 0 leaves the critical section
Number of threads generated: 3

Los resultados son similares a los anteriores. Se observa que los tres hilos esperan en la barrera hasta que el hilo principal la abre (línea 5).

8.7.6. Las clases CountDownLatch y Semaphore

Dos usos adicionales de las herramientas de sincronización complementan los ejemplos anteriores.

Un objeto [java.util.concurrent.CountDownLatch] es un contador: se crea con un valor inicial N; cada llamada a su método [countDown] lo decrementa; su método [await] bloquea al hilo que lo llama hasta que el contador llega a 0. Una vez que llega a 0, se queda ahí: la barrera queda abierta de forma permanente y deja pasar a todos los hilos. Con N = 1, sirve como “señal de partida” de una carrera; con N = el número de tareas, es una forma de esperar la finalización de N tareas, cada una de las cuales llama a [countDown] cuando termina. El programa [Threads14.java] es el siguiente:

// CountDownLatch: una señal de inicio que libera a todos los hilos en espera

void main() throws InterruptedException {
    // la señal de inicio: una cuenta regresiva que empieza en 1
    var start = new CountDownLatch(1);

    // creación e inicio de 4 hilos
    var threads = new Thread[4];
    for (int i = 0; i < threads.length; i++) {
        threads[i] = Thread.ofPlatform().name(String.valueOf(i)).start(() -> {
            String name = Thread.currentThread().getName();
            IO.println(time() + " : runner " + name + " waits for the start signal");
            try {
                // espera a que la cuenta regresiva llegue a 0
                start.await();
                IO.println(time() + " : runner " + name + " has started");
            } catch (InterruptedException e) {
                IO.println(time() + " : runner " + name + " gave up");
            }
        });
    }

    // el hilo principal espera 1 s y luego da la señal de inicio
    Thread.sleep(1000);
    IO.println(time() + " : start signal");
    // la cuenta regresiva llega a 0: todos los hilos en espera quedan liberados
    start.countDown();
    // espera del fin de los hilos
    for (Thread thread : threads) {
        thread.join();
    }
    IO.println("Value of the countdown: " + start.getCount());
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 5: la cuenta regresiva comienza en 1: la puerta está cerrada;
  • línea 15: cada hilo espera a que la cuenta regresiva llegue a 0. El método [await] puede lanzar [InterruptedException]; si el hilo es interrumpido durante la espera, abandona la carrera (línea 18);
  • línea 27: el hilo principal decrementa la cuenta regresiva en uno después de un segundo; esta llega a 0;
  • línea 32: el método [getCount] devuelve el valor actual de la cuenta regresiva.

Resultados:

> java Threads14.java
19:15:14.328 : runner 2 waits for the start signal
19:15:14.328 : runner 0 waits for the start signal
19:15:14.323 : runner 1 waits for the start signal
19:15:14.329 : runner 3 waits for the start signal
19:15:15.293 : start signal
19:15:15.294 : runner 0 has started
19:15:15.296 : runner 1 has started
19:15:15.296 : runner 3 has started
19:15:15.296 : runner 2 has started
Value of the countdown: 0

Los cuatro corredores partieron juntos, con una diferencia de unos pocos milisegundos entre sí, después de la señal de partida. Un [CountDownLatch] se utiliza una sola vez; la clase [CyclicBarrier] proporciona un punto de encuentro reutilizable (los N hilos se esperan entre sí y luego parten juntos), y la clase [Phaser] generaliza estas dos herramientas.

Volvamos al semáforo en su uso más común: un semáforo de N permisos permite que como máximo N hilos entren a una sección de código a la vez. Esto es útil para limitar el acceso a un recurso disponible en cantidad limitada (conexiones a una base de datos, solicitudes simultáneas a un servidor, etc.). El programa [Threads15.java] es el siguiente:

// Semaphore: como máximo N hilos a la vez en una sección de código

void main() throws InterruptedException {
    // un semáforo con 2 permisos (2 plazas)
    var semaphore = new Semaphore(2);

    // creación e inicio de 5 hilos
    var threads = new Thread[5];
    for (int i = 0; i < threads.length; i++) {
        threads[i] = Thread.ofPlatform().name(String.valueOf(i)).start(() -> {
            String name = Thread.currentThread().getName();
            IO.println(time() + " : thread " + name + " waits for a place");
            // se solicita una plaza: bloqueante si no queda ninguna
            semaphore.acquireUninterruptibly();
            try {
                IO.println(time() + " : thread " + name + " obtained a place (free places: "
                        + semaphore.availablePermits() + ")");
                // trabajo
                sleep(1000);
            } finally {
                // se devuelve la plaza
                IO.println(time() + " : thread " + name + " releases its place");
                semaphore.release();
            }
        });
    }
    // espera del fin de los hilos
    for (Thread thread : threads) {
        thread.join();
    }
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 5: el semáforo tiene 2 permisos: 2 plazas;
  • línea 14: un hilo solicita una plaza. Si hay una disponible, la toma y continúa; de lo contrario, queda bloqueado hasta que una plaza quede disponible;
  • línea 17: el número de plazas que aún están disponibles;
  • línea 23: el hilo devuelve su plaza, en una cláusula [finally].

Resultados:

> java Threads15.java
19:15:16.772 : thread 0 waits for a place
19:15:16.773 : thread 0 obtained a place (free places: 1)
19:15:16.776 : thread 3 waits for a place
19:15:16.776 : thread 3 obtained a place (free places: 0)
19:15:16.770 : thread 2 waits for a place
19:15:16.768 : thread 1 waits for a place
19:15:16.767 : thread 4 waits for a place
19:15:17.774 : thread 0 releases its place
19:15:17.775 : thread 2 obtained a place (free places: 0)
19:15:17.776 : thread 3 releases its place
19:15:17.777 : thread 1 obtained a place (free places: 0)
19:15:18.775 : thread 2 releases its place
19:15:18.777 : thread 4 obtained a place (free places: 0)
19:15:18.777 : thread 1 releases its place
19:15:19.780 : thread 4 releases its place

Los cinco hilos solicitan una plaza; dos la obtienen de inmediato, mientras que los otros tres esperan. Cada vez que un hilo libera su plaza, un hilo en espera la obtiene. Nunca hay más de dos hilos en la sección de código. Un semáforo de un solo permiso actúa como un bloqueo, como en el programa [Threads13.java]. Con hilos virtuales, el semáforo es la herramienta natural para limitar la concurrencia: en lugar de limitar el número de hilos, se crea un hilo virtual por cada tarea y se usa un semáforo para limitar el número de tareas que usan simultáneamente el recurso escaso.

8.7.7. Visibilidad de las escrituras: la palabra clave volatile

Los bloqueos no sirven solo para hacer indivisible un grupo de operaciones. Resuelven un segundo problema, más insidioso: la visibilidad de las escrituras. Para acelerar la ejecución, el procesador almacena valores en sus registros y cachés, y el compilador reordena o elimina lecturas y escrituras sobre la marcha, como vimos con el programa [Threads09.java]. Como resultado, un valor escrito por un hilo puede no ser visto por otro hilo hasta más tarde, o quizá nunca.

El Modelo de memoria de Java define con precisión cuándo se garantiza que una escritura sea visible: cuando existe una relación “happens-before” entre la escritura y la lectura. Las principales son las siguientes:

  • todo lo que un hilo ha hecho antes de liberar un bloqueo (fin de un bloque [synchronized], [unlock]) es visible para el hilo que adquiere posteriormente ese bloqueo;
  • lo que el hilo llamador hizo antes de [start] es visible para el hilo llamado; lo que un hilo hizo es visible para el hilo que esperó su finalización mediante [join];
  • una escritura en un campo [volatile] es visible para cualquier lectura posterior de ese campo;
  • las herramientas de [java.util.concurrent] ofrecen garantías similares: lo que un hilo hizo antes de [release()], [countDown()], o de la inserción de un elemento en una colección concurrente, es visible para el hilo que ejecuta posteriormente [acquire()], [await()], o que retira el elemento.

Cuando no existe ninguna de estas relaciones, se dice que el programa contiene una “carrera de datos” (data race) y no hay ninguna garantía. El programa [Threads16.java] lo ilustra con un escenario común: un indicador que ordena a un hilo detenerse.

// visibilidad de las escrituras entre hilos: la palabra clave volatile

void main() throws InterruptedException {
    // 1 - el indicador de parada es un campo ordinario
    Thread t1 = Thread.ofPlatform().name("T1").daemon().start(() -> {
        long rounds = 0;
        while (!Flags.stop) {
            rounds++;
        }
        IO.println(time() + " : T1 saw the stop request after %,d rounds".formatted(rounds));
    });
    // 2 - el indicador de parada es un campo volatile
    Thread t2 = Thread.ofPlatform().name("T2").daemon().start(() -> {
        long rounds = 0;
        while (!Flags.volatileStop) {
            rounds++;
        }
        IO.println(time() + " : T2 saw the stop request after %,d rounds".formatted(rounds));
    });

    // se deja correr a los hilos durante un segundo
    Thread.sleep(1000);
    IO.println(time() + " : Main requests T1 and T2 to stop");
    Flags.stop = true;
    Flags.volatileStop = true;
    // espera del fin de los dos hilos, como máximo 2 s cada uno
    for (Thread thread : List.of(t2, t1)) {
        boolean finished = thread.join(Duration.ofSeconds(2));
        IO.println(time() + " : " + thread.getName() + " finished: " + finished);
    }
}

// los indicadores de parada, compartidos por los hilos
static class Flags {
    // un campo ordinario: un hilo puede no ver nunca el nuevo valor
    static boolean stop;
    // un campo volatile: toda escritura es visible para las lecturas que la siguen
    static volatile boolean volatileStop;
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • líneas 5–11: el hilo T1 se ejecuta mientras el campo ordinario [Flags.stop] sea igual a [false];
  • líneas 13–19: el hilo T2 hace lo mismo con el campo [volatile] and [Flags.volatileStop];
  • líneas 24–25: después de un segundo, el hilo principal pone ambos indicadores en [true];
  • líneas 27–30: espera a cada uno de los dos hilos durante no más de 2 segundos. Ambos hilos son demonios (daemon), de modo que el programa puede terminar aunque alguno de ellos siga en ejecución;
  • líneas 34–39: los dos indicadores. La palabra clave [volatile] (línea 38) especifica que toda operación de lectura del campo debe leer desde la memoria y que toda operación de escritura debe realizarse de inmediato.

Resultados:

1
2
3
4
5
> java Threads16.java
19:15:23.635 : Main requests T1 and T2 to stop
19:15:23.677 : T2 saw the stop request after 315,278,741 rounds
19:15:23.714 : T2 finished: true
19:15:25.729 : T1 finished: false

El hilo T2 vio la solicitud de detención de inmediato. El hilo T1, en cambio, nunca la vio: seguía ejecutándose dos segundos después y solo se detuvo cuando se cerró la máquina virtual. El compilador just-in-time, al notar que el bucle de las líneas 7–9 no modifica [stop] y que ninguna sincronización exige volver a leerlo, leyó este campo una sola vez, antes del bucle: el bucle se convirtió así en un bucle infinito. Este comportamiento es reproducible con la máquina virtual HotSpot utilizada aquí, pero no está garantizado: otra máquina virtual, u otra versión, podría permitir que T1 se detuviera. Ese es precisamente el problema: sin una relación happens-before, el comportamiento del programa es indefinido.

La palabra clave [volatile] garantiza la visibilidad, pero no la atomicidad: [value++] sobre un campo [volatile] sigue siendo una lectura seguida de una escritura, y dos hilos aún pueden perder una actualización. [volatile] es, por lo tanto, adecuado para un indicador escrito por un hilo y leído por otros, pero no para un contador compartido. Para detener un hilo, la interrupción descrita anteriormente es en realidad preferible a un indicador: además, despierta a un hilo que está bloqueado en una espera.

8.7.8. Clases atómicas

El paquete [java.util.concurrent.atomic] (Java 5) proporciona clases que hacen atómicas las operaciones simples sobre una variable: la operación se ejecuta por completo en el hilo, sin que ningún otro hilo pueda observar o modificar la variable en medio de la operación. Las herramientas anteriores ([synchronized], [ReentrantLock], [Semaphore]) están diseñadas para hacer atómico un grupo de operaciones, al costo de bloquear a otros hilos. Para operaciones simples pero frecuentes, las clases atómicas evitan este bloqueo mediante instrucciones especiales del procesador. Los principales métodos de la clase [AtomicInteger] son los siguientes:

Método
Función
[int get()], [void set(int v)]
lee y escribe el valor (con la semántica de un campo [volatile])
[int incrementAndGet()], [int decrementAndGet()]
incrementa (decrementa) el valor en 1 y devuelve el nuevo valor
[int getAndIncrement()], [int getAndDecrement()]
igual que los anteriores, pero devuelve el valor previo (como [x++] y [x--])
[int addAndGet(int delta)]
suma [delta] al valor y devuelve el nuevo valor
[int getAndSet(int v)]
asigna [v] y devuelve el valor anterior
[boolean compareAndSet(int expectedValue, int newValue)]
asigna [newValue] solo si el valor es [expectedValue]; devuelve [true] si la asignación se realizó
[int updateAndGet(IntUnaryOperator f)]
reemplaza el valor v por f(v) de forma atómica y devuelve el nuevo valor

El paquete también ofrece [AtomicLong], [AtomicBoolean], [AtomicReference<V>] (una referencia atómica a un objeto) y arreglos atómicos ([AtomicIntegerArray]…). La clase [LongAdder] (Java 8) es un contador diseñado para actualizaciones muy frecuentes por parte de muchos hilos: en lugar de una única variable por la que compiten todos los hilos, distribuye los incrementos entre varias celdas, que solo se suman cuando se solicita el total ([sum]).

El programa [Threads17.java] parte del experimento del programa [Threads09.java] y compara cinco formas de incrementar el contador compartido:

// clases atómicas: operaciones sin bloqueo

// parámetros: número de hilos, número de incrementos por hilo
int nbThreads;
int nbIncrements;

void main(String[] args) throws InterruptedException {
    nbThreads = args.length > 0 ? Integer.parseInt(args[0]) : 4;
    nbIncrements = args.length > 1 ? Integer.parseInt(args[1]) : 10_000_000;
    IO.println("%d threads, %,d increments per thread, expected value %,d"
            .formatted(nbThreads, nbIncrements, nbThreads * nbIncrements));

    // cinco formas de incrementar un contador compartido
    measure("without synchronization", Counter::withoutSynchronization, () -> Counter.value);
    measure("with synchronized", Counter::withSynchronized, () -> Counter.value);
    measure("with ReentrantLock", Counter::withReentrantLock, () -> Counter.value);
    measure("with AtomicInteger", Counter::withAtomicInteger, Counter.atomic::get);
    measure("with LongAdder", Counter::withLongAdder, Counter.adder::sum);
}

// inicia los hilos que ejecutan todos [increment] nbIncrements veces, y luego muestra [value]
void measure(String method, Runnable increment, LongSupplier value) throws InterruptedException {
    Counter.reset();
    // una señal de inicio para que todos los hilos comiencen al mismo tiempo
    var start = new CountDownLatch(1);
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++) {
        threads[i] = Thread.ofPlatform().start(() -> {
            try {
                start.await();
            } catch (InterruptedException e) {
                return;
            }
            for (int j = 0; j < nbIncrements; j++) {
                increment.run();
            }
        });
    }
    // ¡ya!
    long begin = System.nanoTime();
    start.countDown();
    for (Thread thread : threads) {
        thread.join();
    }
    long duration = (System.nanoTime() - begin) / 1_000_000;
    IO.println("%-24s : obtained value %,12d in %5d ms".formatted(method, value.getAsLong(), duration));
}

// el recurso compartido
static class Counter {
    // volatile garantiza la visibilidad de las escrituras, no la atomicidad de value++
    static volatile int value;
    private static final Object lock = new Object();
    private static final ReentrantLock reentrantLock = new ReentrantLock();
    static final AtomicInteger atomic = new AtomicInteger();
    static final LongAdder adder = new LongAdder();

    // puesta a cero de los contadores
    static void reset() {
        value = 0;
        atomic.set(0);
        adder.reset();
    }

    // leer, incrementar, escribir: no es atómico
    static void withoutSynchronization() {
        value++;
    }

    // sección crítica protegida por synchronized
    static void withSynchronized() {
        synchronized (lock) {
            value++;
        }
    }

    // sección crítica protegida por un ReentrantLock
    static void withReentrantLock() {
        reentrantLock.lock();
        try {
            value++;
        } finally {
            reentrantLock.unlock();
        }
    }

    // incremento atómico, sin bloqueo
    static void withAtomicInteger() {
        atomic.incrementAndGet();
    }

    // incremento de un sumador distribuido, sin bloqueo
    static void withLongAdder() {
        adder.increment();
    }
}

Comentarios:

  • líneas 4–5: en un archivo fuente compacto, los campos pueden declararse fuera de cualquier clase; son campos de la clase implícita. Los utilizan los métodos de instancia [main] y [measure];
  • líneas 14–18: el método [measure] se llama con cinco métodos de incremento diferentes, pasados como [Runnable], y con una función que devuelve el valor resultante, de tipo [LongSupplier] (una interfaz funcional de tipo [long getAsLong()]). Las referencias a métodos [Counter.atomic::get] y [Counter.adder::sum] remiten a métodos de dos objetos específicos;
  • líneas 22–47: el método [measure] lanza [nbThreads] hilos, cada uno de los cuales llama al método recibido [nbIncrements] veces, y mide el tiempo total. El formato [%,12d] alinea el valor a la derecha en 12 caracteres, con separador de miles;
  • líneas 25, 30 y 41: todos los hilos esperan detrás de un [CountDownLatch], que se abre una vez que todos han sido lanzados. Así comienzan su trabajo al mismo tiempo, lo que hace los accesos concurrentes mucho más probables que con hilos lanzados uno tras otro;
  • línea 52: el contador es [volatile]. Esto impide que el compilador realice sobre la marcha la optimización que observamos con [Threads09.java]: cada incremento lee y escribe realmente en la memoria;
  • línea 67: el incremento sin sincronización;
  • líneas 72–74 y 79–84: el incremento dentro de una sección crítica protegida por [synchronized] o por un [ReentrantLock];
  • línea 89: incremento atómico;
  • línea 94: incremento de un [LongAdder].

Resultados:

1
2
3
4
5
6
7
> java Threads17.java
4 threads, 10,000,000 increments per thread, expected value 40,000,000
without synchronization  : obtained value   22,447,283 in   729 ms
with synchronized        : obtained value   40,000,000 in  3789 ms
with ReentrantLock       : obtained value   40,000,000 in  1145 ms
with AtomicInteger       : obtained value   40,000,000 in   739 ms
with LongAdder           : obtained value   40,000,000 in   293 ms
  • Sin sincronización, el resultado vuelve a ser incorrecto: el campo [volatile] no hizo atómico a [value++];
  • los otros cuatro métodos devuelven el resultado correcto;
  • Las clases atómicas son notablemente más rápidas que los bloqueos en esta ejecución. Los bloqueos resultan costosos aquí porque cuatro hilos compiten constantemente por ellos para una operación minúscula. Los tiempos de ejecución medidos dependen en gran medida de la máquina y de su carga: solo su orden de magnitud es significativo. [LongAdder] fue el más rápido: sus hilos interfieren menos entre sí que los que compiten por la única variable de un [AtomicInteger], y su ventaja de rendimiento aumenta con el número de procesadores.

El método [compareAndSet] (“CAS”) es la pieza fundamental de los algoritmos “sin bloqueo” (lock-free): se lee el valor, se calcula el nuevo y solo se escribe si la variable no ha cambiado entretanto; de lo contrario, se vuelve a empezar. Esto es lo que hace [updateAndGet], y las colecciones concurrentes que se presentan más adelante lo utilizan ampliamente.

8.8. Acceso concurrente a varios recursos compartidos

8.8.1. Interbloqueo

En nuestros ejemplos anteriores, se compartía un único recurso entre los distintos hilos. La situación se complica si hay varios recursos y dependen unos de otros. En particular, puede producirse un interbloqueo (deadlock): dos hilos se esperan mutuamente. Considere las siguientes acciones, que ocurren de forma secuencial:

  • un hilo T1 adquiere el bloqueo V1 para acceder a un recurso compartido R1;
  • un hilo T2 adquiere el bloqueo V2 para acceder a un recurso compartido R2;
  • el hilo T1 solicita el bloqueo V2. Queda bloqueado;
  • el hilo T2 solicita el bloqueo V1. Queda bloqueado.

Los hilos T1 y T2 se esperan mutuamente de forma indefinida. Hay varias soluciones posibles:

  • solicitar ambos recursos a la vez mediante un único bloqueo. Esto no siempre es posible si implica un bloqueo prolongado de un recurso costoso;
  • adquirir siempre los bloqueos en el mismo orden: si todos los hilos adquieren V1 antes que V2, el interbloqueo es imposible. Esta es la regla más utilizada;
  • un hilo que posee V1 y no puede adquirir V2 libera V1 para evitar el interbloqueo.

El programa [Threads18.java] provoca un interbloqueo e implementa la última solución, mediante el método [tryLock] de [ReentrantLock]:

// interbloqueo: dos hilos toman dos bloqueos en orden distinto

void main() throws InterruptedException {
    // los bloqueos de los dos recursos compartidos
    var lockR1 = new ReentrantLock();
    var lockR2 = new ReentrantLock();

    // T1 toma R1 y luego solicita R2; desiste tras 2 s
    var t1 = new Thread(() -> work(lockR1, "R1", lockR2, "R2", Duration.ofSeconds(2)), "T1");
    // T2 toma R2 y luego solicita R1; espera hasta 5 s
    var t2 = new Thread(() -> work(lockR2, "R2", lockR1, "R1", Duration.ofSeconds(5)), "T2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    IO.println("End of Main");
}

// toma el 1.er recurso y luego intenta tomar el 2.º durante [timeout]
static void work(Lock first, String firstName, Lock second, String secondName, Duration timeout) {
    String name = Thread.currentThread().getName();
    first.lock();
    try {
        IO.println(time() + " : " + name + " obtained " + firstName);
        // se da tiempo al otro hilo para que tome su primer recurso
        Thread.sleep(500);
        IO.println(time() + " : " + name + " requests " + secondName);
        // solicitud con un tiempo máximo de espera, en lugar de un lock() que esperaría indefinidamente
        if (second.tryLock(timeout.toMillis(), TimeUnit.MILLISECONDS)) {
            try {
                IO.println(time() + " : " + name + " obtained " + secondName
                        + " and works with " + firstName + " and " + secondName);
            } finally {
                second.unlock();
            }
        } else {
            IO.println(time() + " : " + name + " did not obtain " + secondName + " within " + timeout.toSeconds()
                    + " s: it releases " + firstName + " and gives up");
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        first.unlock();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • líneas 5–6: los bloqueos de los dos recursos. Aquí son variables locales, capturadas por las lambdas de las líneas 9 y 11;
  • Línea 9: el hilo T1 adquiere R1 y luego solicita R2; espera como máximo 2 segundos;
  • línea 11: el hilo T2 adquiere R2 y luego solicita R1, es decir, en orden inverso; espera como máximo 5 segundos;
  • línea 20: el método [work] adquiere bloqueos del tipo definido por la interfaz [Lock], que implementa [ReentrantLock];
  • línea 22: el hilo adquiere su primer recurso. La cláusula [finally] de la línea 42 lo liberará en cualquier caso;
  • línea 26: espera medio segundo, lo que da tiempo al otro hilo para adquirir su propio primer recurso: el interbloqueo es entonces seguro;
  • línea 29: en lugar de un [lock], que esperaría indefinidamente, el hilo solicita el segundo bloqueo con un tiempo máximo de espera. [tryLock] devuelve [true] si se obtuvo el bloqueo, y [false] si el tiempo de espera expiró. El tiempo de espera se expresa mediante un número y una unidad ([TimeUnit.MILLISECONDS]); el método [toMillis()] convierte la duración [timeout] a milisegundos;
  • línea 34: un bloqueo adquirido mediante [tryLock] debe liberarse con [unlock], dentro de una cláusula [finally];
  • líneas 36–39: si no se pudo adquirir el segundo bloqueo, el hilo aborta. Al salir del método, libera su primer recurso (línea 43);
  • líneas 40–41: [sleep] y [tryLock], con un tiempo de espera, pueden lanzar [InterruptedException].

Resultados:

1
2
3
4
5
6
7
8
> java Threads18.java
19:15:36.043 : T1 obtained R1
19:15:36.033 : T2 obtained R2
19:15:36.553 : T2 requests R1
19:15:36.554 : T1 requests R2
19:15:38.554 : T1 did not obtain R2 within 2 s: it releases R1 and gives up
19:15:38.558 : T2 obtained R1 and works with R2 and R1
End of Main

Cada uno de los dos hilos obtuvo su primer recurso y luego solicitó el segundo: están en interbloqueo. Tras 2 segundos, T1 desiste y libera R1; T2, que seguía esperando, obtiene R1 de inmediato y puede hacer su trabajo. Sin un tiempo de espera, el programa nunca habría terminado. Esta secuencia de eventos es reproducible; solo puede cambiar el orden de las líneas 2 y 3 y el de las líneas 4 y 5. No sería posible escribir este programa con bloques [synchronized], ya que su tiempo de espera no puede limitarse.

Cuando un programa Java parece estar congelado, el comando [jcmd <pid> Thread.print] del JDK muestra la pila de llamadas de cada uno de sus hilos ([pid] es el identificador del proceso, que devuelve el comando [jcmd] sin ningún parámetro); detecta los interbloqueos entre bloqueos y los informa con el mensaje “Found one Java-level deadlock”, seguido de los hilos y bloqueos involucrados.

8.8.2. Un ejemplo: lectores y escritores

Considere el siguiente ejemplo:

  • tenemos un arreglo en el que algunos hilos escriben datos (los escritores) y otros los leen (los lectores);
  • los escritores son iguales entre sí pero exclusivos: solo un escritor a la vez puede escribir datos en el arreglo;
  • los lectores son iguales entre sí pero exclusivos: solo un lector a la vez puede leer los datos almacenados en el arreglo;
  • un lector solo puede leer datos del arreglo cuando un escritor ha colocado algunos allí, y un escritor solo puede colocar nuevos datos en el arreglo cuando los datos que ya están allí han sido leídos por un lector.

Hay dos tipos de recursos compartidos:

  • la tabla de escritura: solo un escritor a la vez puede acceder a ella;
  • la tabla de lectura: solo un lector a la vez puede acceder a ella.

y un orden de utilización de estos recursos:

  • un lector debe seguir siempre a un escritor;
  • un escritor debe seguir siempre a un lector, excepto la primera vez.

El acceso a estos dos recursos puede controlarse mediante dos barreras de tipo [Semaphore]:

  • la barrera [canWrite] controla el acceso de los escritores al arreglo;
  • la barrera [canRead] controla el acceso de los lectores al arreglo;
  • la barrera [canWrite] se crea abierta (un permiso), lo que permite pasar al primer escritor y bloquea a todos los demás;
  • la barrera [canRead] se crea en estado cerrado (sin permisos), lo que bloquea a todos los lectores;
  • cuando un escritor ha terminado su trabajo, abre la barrera [canRead] para dejar entrar a un lector;
  • cuando un lector ha terminado su trabajo, abre la barrera [canWrite] para dejar entrar a un escritor.

Aquí se aprecia la utilidad de una barrera que no pertenece a ningún hilo: la barrera [canRead] la cierra un lector (que toma el permiso) y la abre un escritor (que lo devuelve). Esto es imposible con un bloqueo, que solo puede ser liberado por el hilo que lo posee. El programa [Threads19.java] que ilustra esta sincronización es el siguiente:

// lectores y escritores sincronizados con dos semáforos

void main() {
    // el número de hilos de cada tipo
    final int nbThreads = 2;

    // creación e inicio de los hilos lectores
    for (int i = 0; i < nbThreads; i++) {
        new Thread(Board::read, "R" + i).start();
    }
    // creación e inicio de los hilos escritores
    for (int i = 0; i < nbThreads; i++) {
        new Thread(Board::write, "W" + i).start();
    }
    // fin de main: los demás hilos continúan su trabajo
    IO.println("End of Main...");
}

// el recurso compartido y su sincronización
static class Board {
    // el arreglo compartido entre lectores y escritores
    private static final int[] data = new int[3];
    // indica que el contenido de data puede leerse: cerrado al inicio (sin permiso)
    private static final Semaphore canRead = new Semaphore(0);
    // indica que se puede escribir en data: abierto al inicio (un permiso)
    private static final Semaphore canWrite = new Semaphore(1);

    // leer el contenido del arreglo
    static void read() {
        String name = Thread.currentThread().getName();
        IO.println("Method [read] started by thread " + name);
        // se espera el permiso de lectura
        canRead.acquireUninterruptibly();
        // lectura del arreglo
        for (int i = 0; i < data.length; i++) {
            // espera de 0,5 s: el hilo pierde el procesador
            sleep(500);
            IO.println(time() + " : reader " + name + " read the number " + data[i]);
        }
        // se permite un escritor
        canWrite.release();
        IO.println("Method [read] finished by thread " + name);
    }

    // escribir en el arreglo
    static void write() {
        String name = Thread.currentThread().getName();
        IO.println("Method [write] started by thread " + name);
        // se espera el permiso de escritura
        canWrite.acquireUninterruptibly();
        // escritura del arreglo
        for (int i = 0; i < data.length; i++) {
            // espera de 0,5 s
            sleep(500);
            // ThreadLocalRandom: un generador de números aleatorios propio de cada hilo
            data[i] = ThreadLocalRandom.current().nextInt(0, 1000);
            IO.println(time() + " : writer " + name + " wrote the number " + data[i]);
        }
        // se permite un lector
        canRead.release();
        IO.println("Method [write] finished by thread " + name);
    }
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • líneas 8–14: creación e inicio de dos hilos lectores, seguidos de dos hilos escritores. No se conserva ninguna referencia a los hilos: el hilo principal no los espera;
  • línea 16: el hilo principal termina de inmediato. El proceso continúa hasta que los cuatro hilos, que no son demonios, hayan terminado;
  • línea 22: el arreglo [data] es el recurso compartido entre los hilos lectores y escritores;
  • línea 24: la barrera [canRead] indica a los lectores que pueden leer el arreglo. La abre el escritor que ha llenado el arreglo. Se crea en estado cerrado: un escritor debe llenar primero el arreglo;
  • línea 26: la barrera [canWrite] notifica a los escritores que pueden escribir en el arreglo. La abre el lector que ha leído todo el arreglo. Se crea abierta: el arreglo es escribible desde el inicio;
  • línea 33: un lector espera a que un escritor señale que el arreglo ha sido llenado. Cuando llega esta señal, solo uno de los lectores en espera continúa;
  • líneas 35–39: se lee el arreglo, con una pausa de medio segundo en cada elemento para obligar al hilo a ceder la CPU;
  • línea 41: el lector notifica a los escritores que el arreglo ha sido leído y que puede volver a llenarse;
  • el método [write] es simétrico al método [read];
  • línea 56: los números escritos se generan de forma aleatoria. El método [ThreadLocalRandom.current()] (Java 7) devuelve un generador de números aleatorios propio del hilo actual: los hilos no compiten por un único generador. El método [nextInt(0, 1000)] devuelve un entero del intervalo [0, 1000[;
  • el arreglo [data] no está protegido por ningún bloqueo. Sin embargo, no hay carrera de datos: las escrituras del escritor preceden a su [canRead.release()], que precede (relación happens-before) al [canRead.acquireUninterruptibly()] del lector y, por lo tanto, a sus lecturas.

Resultados:

> java Threads19.java
Method [read] started by thread R0
Method [read] started by thread R1
Method [write] started by thread W0
End of Main...
Method [write] started by thread W1
19:15:41.498 : writer W0 wrote the number 408
19:15:42.004 : writer W0 wrote the number 58
19:15:42.505 : writer W0 wrote the number 490
Method [write] finished by thread W0
19:15:43.006 : reader R0 read the number 408
19:15:43.507 : reader R0 read the number 58
19:15:44.016 : reader R0 read the number 490
Method [read] finished by thread R0
19:15:44.520 : writer W1 wrote the number 310
19:15:45.020 : writer W1 wrote the number 964
19:15:45.520 : writer W1 wrote the number 830
Method [write] finished by thread W1
19:15:46.021 : reader R1 read the number 310
19:15:46.521 : reader R1 read the number 964
19:15:47.022 : reader R1 read the number 830
Method [read] finished by thread R1

Pueden observarse los siguientes puntos:

  • solo hay un lector a la vez, aunque pierda la CPU en la sección crítica [read];
  • solo hay un escritor a la vez, aunque pierda el procesador en la sección crítica [write];
  • un lector lee solo cuando hay algo que leer en el arreglo;
  • un escritor escribe solo cuando el arreglo ha sido leído por completo;
  • Por otra parte, no tenemos ningún control sobre el orden en que aparecen: no había ninguna razón para que el escritor W0 fuera antes que el escritor W1, ni para que el lector R0 fuera antes que el lector R1. Una ejecución diferente puede producir un orden distinto.

8.8.3. Los métodos wait y notifyAll

En el ejemplo anterior, cuando los escritores están bloqueados en la instrucción [canWrite.acquireUninterruptibly()], uno de ellos, cualquiera, es desbloqueado por la operación [canWrite.release()]. Si se desea abrir la barrera para un escritor específico, las cosas se complican.

Consideremos la analogía de una oficina de servicios públicos con ventanillas de atención. Cuando llega un cliente, toma un número del dispensador y luego va a sentarse. A los clientes se les llama por su número mediante un altavoz. Mientras espera, el cliente puede hacer lo que quiera: puede leer o dormitar. Se despierta cada vez que el altavoz anuncia un número. Si es su número, el cliente se levanta y va a la ventanilla; de lo contrario, vuelve a lo que estaba haciendo. Podemos proceder de manera similar con los hilos. Tomemos el ejemplo de los escritores:

En la ventanilla
Con hilos
varios escritores esperan en la misma ventanilla
sus hilos están bloqueados
la ventanilla queda disponible y se llama al número del siguiente escritor
el hilo que estaba leyendo el arreglo notifica a los escritores que el arreglo está disponible. Ese hilo u otro ha determinado qué escritor debe continuar
Cada escritor verifica su número; solo el que tiene el número llamado pasa a la ventanilla; los demás vuelven a la cola de espera
Cada hilo verifica si es el elegido. Si lo es, atraviesa la barrera; de lo contrario, vuelve a la cola de espera

Java permite implementar este escenario mediante métodos disponibles en todos los objetos, ya que están definidos en la clase [Object]:

Método
Función
[void wait()]
devuelve el monitor del objeto y bloquea el hilo hasta que otro hilo señale un cambio mediante [notify] o [notifyAll]; el hilo debe entonces recuperar el monitor antes de continuar. La espera puede ser interrumpida ([InterruptedException])
[void wait(long ms)]
igual que el anterior, con un tiempo máximo de espera
[void notify()]
despierta a uno de los hilos bloqueados por [wait] en este objeto
[void notifyAll()]
despierta a todos los hilos bloqueados por [wait] en este objeto

Describiremos ahora un patrón estándar, presentado en particular en el libro de Brian Goetz et al., [Java Concurrency in Practice], que permite resolver problemas de barreras con condiciones de entrada.

Los hilos que comparten un recurso (el mostrador) acceden a él mediante un objeto que llamaremos token: es un objeto simple ([new Object()]) cuyo monitor se utiliza. Para cruzar la barrera que lleva al mostrador, hay que tener el token, y solo hay uno. Por lo tanto, los hilos deben pasarse el token entre sí.

Para ir al mostrador, un hilo solicita primero el token mediante un bloque [synchronized (token)]. Si obtiene el token, verifica en un bucle [while (!iAmTheExpectedOne) { token.wait(); }] si cumple la condición para pasar al mostrador y luego pasa al mostrador, siempre dentro del bloque [synchronized]. Si el hilo no es el esperado en el mostrador, cede su turno devolviendo el token mediante [token.wait()] y entra en el estado bloqueado. Será despertado cuando otro hilo señale un cambio en la condición de acceso; recuperará entonces el token y verificará de nuevo la condición. Por eso la prueba es un bucle ([while]) y no un simple [if]. Hay una segunda razón, propia de Java: la especificación admite los “despertares espurios” (spurious wakeups), en los que [wait] termina sin que ningún hilo haya llamado a [notify]; el bucle los vuelve inofensivos. La operación [token.wait()] solo puede ser realizada por un hilo que posea el monitor del token; de lo contrario, se lanza una excepción [IllegalMonitorStateException]. En este esquema, el token solo se libera una vez finalizada la transacción.

El hilo que modifica la condición de acceso al mostrador también debe poseer el token y notificar a los hilos en espera: dentro de un bloque [synchronized (token)], modifica la condición de acceso al mostrador y luego despierta a los hilos en espera mediante [token.notifyAll()].

Despertar a los hilos significa que los hilos en espera pasan a ser candidatos al token; no lo reciben de inmediato. El token solo queda disponible al final del bloque [synchronized]. Todos los hilos despertados recibirán entonces el token por turnos, en un orden indeterminado, lo que les da la oportunidad de verificar de nuevo la condición de acceso. El primero que cumpla la condición conserva el token y pasa a la fila.

Con esta información, podemos reescribir la aplicación de lectores y escritores especificando el orden en que los lectores y los escritores pasan a sus respectivos mostradores ([Threads20.java]):

// lectores y escritores que pasan por el contador en un orden impuesto: wait / notifyAll

void main() {
    // el número de hilos de cada tipo
    final int nbThreads = 3;

    // el orden de los lectores: el inverso al orden de creación
    Board.readOrder = IntStream.range(0, nbThreads).mapToObj(i -> "R" + (nbThreads - 1 - i)).toList();
    // el orden de los escritores: el orden de creación
    Board.writeOrder = IntStream.range(0, nbThreads).mapToObj(i -> "W" + i).toList();
    for (int i = 0; i < nbThreads; i++) {
        IO.println("Reader " + Board.readOrder.get(i) + " is in position " + i
                + ", writer " + Board.writeOrder.get(i) + " is in position " + i);
    }

    // creación e inicio de los hilos lectores y luego de los hilos escritores
    for (int i = 0; i < nbThreads; i++) {
        new Thread(Board::read, "R" + i).start();
    }
    for (int i = 0; i < nbThreads; i++) {
        new Thread(Board::write, "W" + i).start();
    }

    // autorización de escritura
    Board.allowWriting();
    // fin de main
    IO.println("End of Main...");
}

// el recurso compartido y su sincronización
static class Board {
    // el arreglo compartido entre lectores y escritores
    private static final int[] data = new int[3];
    // los testigos de acceso de los contadores de lectura y escritura
    private static final Object canRead = new Object();
    private static final Object canWrite = new Object();
    // las condiciones de acceso de los contadores
    private static boolean readingAllowed = false;
    private static boolean writingAllowed = false;
    private static int nextReader = 0;
    private static int nextWriter = 0;
    // el orden de los lectores y de los escritores
    static List<String> readOrder = List.of();
    static List<String> writeOrder = List.of();

    // abre el contador de escritura
    static void allowWriting() {
        synchronized (canWrite) {
            writingAllowed = true;
            // se despierta a todos los escritores que esperan el testigo
            canWrite.notifyAll();
        }
    }

    // leer el contenido del arreglo
    static void read() {
        String name = Thread.currentThread().getName();
        IO.println("Method [read] started by thread " + name);
        // se solicita el testigo del contador de lectura
        synchronized (canRead) {
            try {
                // mientras no sea nuestro turno, se devuelve el testigo y se espera
                while (!readingAllowed || !readOrder.get(nextReader).equals(name)) {
                    canRead.wait();
                }
            } catch (InterruptedException e) {
                return;
            }
            // en el contador: lectura del arreglo
            for (int i = 0; i < data.length; i++) {
                sleep(500);
                IO.println(time() + " : reader " + name + " read the number " + data[i]);
            }
            // siguiente lector
            readingAllowed = false;
            nextReader++;
            // se notifica a los escritores que pueden escribir
            synchronized (canWrite) {
                writingAllowed = true;
                canWrite.notifyAll();
            }
            IO.println("Method [read] finished by thread " + name);
        }
    }

    // escribir en el arreglo
    static void write() {
        String name = Thread.currentThread().getName();
        IO.println("Method [write] started by thread " + name);
        // se solicita el testigo del contador de escritura
        synchronized (canWrite) {
            try {
                // mientras no sea nuestro turno, se devuelve el testigo y se espera
                while (!writingAllowed || !writeOrder.get(nextWriter).equals(name)) {
                    canWrite.wait();
                }
            } catch (InterruptedException e) {
                return;
            }
            // en el contador: escritura del arreglo
            for (int i = 0; i < data.length; i++) {
                sleep(500);
                data[i] = ThreadLocalRandom.current().nextInt(0, 1000);
                IO.println(time() + " : writer " + name + " wrote the number " + data[i]);
            }
            // siguiente escritor
            writingAllowed = false;
            nextWriter++;
            // se notifica a los lectores que pueden leer
            synchronized (canRead) {
                readingAllowed = true;
                canRead.notifyAll();
            }
            IO.println("Method [write] finished by thread " + name);
        }
    }
}

El acceso al mostrador de lectura está determinado por lo siguiente:

  • línea 35: el token [canRead];
  • línea 38: el valor booleano [readingAllowed];
  • Línea 43: la lista ordenada de los nombres de los lectores. Los lectores pasan al puesto de lectura en el orden indicado aquí;
  • línea 40: [nextReader] es el índice, en esta lista, del siguiente lector autorizado a pasar al mostrador.

El acceso al mostrador de escritura se controla de manera similar mediante el token [canWrite], el booleano [writingAllowed], la lista [writeOrder], y el índice [nextWriter].

El programa principal:

  • líneas 8–10: los lectores pasarán al mostrador en orden inverso al de su creación (R2, R1, R0), y los escritores en el orden en que fueron creados (W0, W1, W2). Las listas se construyen mediante un pipeline: [IntStream.range(0, nbThreads)] genera los enteros 0, 1, 2; [mapToObj] convierte cada uno de ellos en un nombre de hilo; y [toList()] (Java 16) recopila los nombres en una lista de solo lectura;
  • Líneas 17–22: creación e inicio de los lectores, seguidos de los escritores. Todos quedarán bloqueados, ya que no se permite ni leer ni escribir;
  • línea 25: se habilita la escritura y se notifica a los escritores que algo ha cambiado (método [allowWriting], líneas 47–53).

El método [read]:

  • líneas 60–83: todo el proceso en el puesto de lectura está controlado por el bloque [synchronized] sobre el token [canRead]. El lector que lo obtiene lo conserva durante toda su permanencia en el puesto;
  • líneas 63–65: un lector que ha adquirido el token lo devuelve si la lectura no está autorizada o si no es su turno. Los nombres se comparan mediante [equals];
  • líneas 66–68: si el hilo es interrumpido durante la espera, aborta;
  • líneas 70–73: procesamiento en el mostrador (lectura del arreglo);
  • líneas 75–76: el lector cambia las condiciones de acceso de la cola de lectura. Todavía posee el token de lectura, y estos cambios impiden que cualquier lector pase al mostrador;
  • líneas 78–81: el lector cambia las condiciones de acceso de la cola de escritura y notifica a todos los escritores en espera que algo ha cambiado. Para ello, toma el token [canWrite]: aquí vemos que el hilo posee dos tokens al mismo tiempo. Los escritores hacen lo mismo en orden inverso (poseen [canWrite] y solicitan [canRead]), que es la situación de interbloqueo descrita anteriormente. Sin embargo, aquí no hay riesgo: un hilo solicita el segundo token solo al final de su paso por el mostrador, los dos mostradores nunca están ocupados al mismo tiempo, y los demás hilos poseen un token solo el tiempo necesario para verificar la condición de acceso, sin solicitar el otro token.

El método [write] es simétrico al método [read]. Observe el uso de [notifyAll] en lugar de [notify], que despierta solo a un único hilo: si ese hilo no fuera el escritor esperado, volvería a dormirse, y el escritor esperado podría no ser despertado nunca. Con una condición de acceso que especifica un hilo en particular, se debe usar [notifyAll].

A continuación se muestra un ejemplo de ejecución:

> java Threads20.java
Reader R2 is in position 0, writer W0 is in position 0
Reader R1 is in position 1, writer W1 is in position 1
Reader R0 is in position 2, writer W2 is in position 2
Method [write] started by thread W0
Method [read] started by thread R0
Method [read] started by thread R1
Method [read] started by thread R2
End of Main...
Method [write] started by thread W1
Method [write] started by thread W2
19:15:51.612 : writer W0 wrote the number 641
19:15:52.152 : writer W0 wrote the number 32
19:15:52.653 : writer W0 wrote the number 386
Method [write] finished by thread W0
19:15:53.186 : reader R2 read the number 641
19:15:53.687 : reader R2 read the number 32
19:15:54.187 : reader R2 read the number 386
Method [read] finished by thread R2
19:15:54.688 : writer W1 wrote the number 213
19:15:55.188 : writer W1 wrote the number 694
19:15:55.696 : writer W1 wrote the number 502
Method [write] finished by thread W1
19:15:56.200 : reader R1 read the number 213
19:15:56.716 : reader R1 read the number 694
19:15:57.216 : reader R1 read the number 502
Method [read] finished by thread R1
19:15:57.719 : writer W2 wrote the number 102
19:15:58.224 : writer W2 wrote the number 163
19:15:58.732 : writer W2 wrote the number 249
Method [write] finished by thread W2
19:15:59.274 : reader R0 read the number 102
19:15:59.775 : reader R0 read the number 163
19:16:00.275 : reader R0 read the number 249
Method [read] finished by thread R0

Los escritores y los lectores se turnan en sus respectivos mostradores, cada uno en el orden especificado: W0, R2, W1, R1, W2, R0. A diferencia del programa anterior, este orden de paso es reproducible; solo varía de una ejecución a otra el orden de los mensajes “started”.

8.8.4. Condiciones: la interfaz Condition

Los métodos [wait] y [notifyAll] están asociados al monitor de un objeto y, por lo tanto, a los bloques [synchronized]. Para un bloqueo [ReentrantLock], el equivalente es la interfaz [java.util.concurrent.locks.Condition]: un objeto [Condition] se crea con el método [newCondition()] del bloqueo y proporciona los métodos [await()] (el equivalente de [wait]), [await(long time, TimeUnit unit)], [signal()] (el equivalente de [notify]) y [signalAll()] (el equivalente de [notifyAll]). Su uso sigue las mismas reglas: el hilo debe poseer el bloqueo, y la condición de acceso se prueba dentro de un bucle [while].

La ventaja principal es que un único bloqueo puede tener varias condiciones, es decir, varias colas distintas. En nuestro problema, un único bloqueo puede proteger ambos mostradores, con una condición para los lectores y otra para los escritores: un lector que termina despierta a los escritores, y solo a los escritores. Ya no hay dos tokens, por lo que ya no hay que vigilar ningún anidamiento de bloqueos. El programa [Threads21.java] tiene el mismo programa principal que [Threads20.java]; su clase [Board] es la siguiente:

// el recurso compartido y su sincronización
static class Board {
    // el arreglo compartido entre lectores y escritores
    private static final int[] data = new int[3];
    // un único bloqueo para ambos contadores
    private static final ReentrantLock lock = new ReentrantLock();
    // dos condiciones asociadas a este bloqueo: dos colas de espera distintas
    private static final Condition canRead = lock.newCondition();
    private static final Condition canWrite = lock.newCondition();
    // las condiciones de acceso de los contadores
    private static boolean readingAllowed = false;
    private static boolean writingAllowed = false;
    private static int nextReader = 0;
    private static int nextWriter = 0;
    // el orden de los lectores y de los escritores
    static List<String> readOrder = List.of();
    static List<String> writeOrder = List.of();

    // abre el contador de escritura
    static void allowWriting() {
        lock.lock();
        try {
            writingAllowed = true;
            // se despierta a todos los escritores, y solo a ellos
            canWrite.signalAll();
        } finally {
            lock.unlock();
        }
    }

    // leer el contenido del arreglo
    static void read() {
        String name = Thread.currentThread().getName();
        IO.println("Method [read] started by thread " + name);
        lock.lock();
        try {
            // mientras no sea nuestro turno, se devuelve el bloqueo y se espera una señal
            while (!readingAllowed || !readOrder.get(nextReader).equals(name)) {
                canRead.await();
            }
            // en el contador: lectura del arreglo
            for (int i = 0; i < data.length; i++) {
                sleep(500);
                IO.println(time() + " : reader " + name + " read the number " + data[i]);
            }
            // siguiente lector
            readingAllowed = false;
            nextReader++;
            // se notifica a los escritores que pueden escribir
            writingAllowed = true;
            canWrite.signalAll();
            IO.println("Method [read] finished by thread " + name);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }

    // escribir en el arreglo
    static void write() {
        String name = Thread.currentThread().getName();
        IO.println("Method [write] started by thread " + name);
        lock.lock();
        try {
            // mientras no sea nuestro turno, se devuelve el bloqueo y se espera una señal
            while (!writingAllowed || !writeOrder.get(nextWriter).equals(name)) {
                canWrite.await();
            }
            // en el contador: escritura del arreglo
            for (int i = 0; i < data.length; i++) {
                sleep(500);
                data[i] = ThreadLocalRandom.current().nextInt(0, 1000);
                IO.println(time() + " : writer " + name + " wrote the number " + data[i]);
            }
            // siguiente escritor
            writingAllowed = false;
            nextWriter++;
            // se notifica a los lectores que pueden leer
            readingAllowed = true;
            canRead.signalAll();
            IO.println("Method [write] finished by thread " + name);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }
}

Comentarios:

  • línea 35: un único bloqueo no justo;
  • líneas 37–38: dos condiciones creadas a partir de este bloqueo;
  • líneas 49–58: para abrir el canal de escritura, se adquiere el bloqueo, se modifica la condición de acceso y se despierta a los escritores mediante [canWrite.signalAll()];
  • líneas 64–86: el paso al canal de lectura se realiza mientras se posee el bloqueo, según la secuencia [lock] / [try] / [finally] / [unlock];
  • líneas 67–69: hasta que sea su turno, el lector espera en la condición [canRead]. El método [await] libera el bloqueo durante la espera y lo readquiere antes de devolver el control;
  • líneas 79–80: el lector autoriza la escritura y despierta a los escritores. Ya posee el bloqueo: no necesita adquirir un segundo token;
  • líneas 82–83: si el hilo es interrumpido durante la espera, restablece su indicador de interrupción y termina; la cláusula [finally] libera el bloqueo.

Resultados:

> java Threads21.java
Reader R2 is in position 0, writer W0 is in position 0
Reader R1 is in position 1, writer W1 is in position 1
Reader R0 is in position 2, writer W2 is in position 2
Method [read] started by thread R0
Method [read] started by thread R1
Method [read] started by thread R2
Method [write] started by thread W1
Method [write] started by thread W0
End of Main...
Method [write] started by thread W2
19:16:04.039 : writer W0 wrote the number 735
19:16:04.610 : writer W0 wrote the number 678
19:16:05.120 : writer W0 wrote the number 594
Method [write] finished by thread W0
19:16:05.621 : reader R2 read the number 735
19:16:06.158 : reader R2 read the number 678
19:16:06.660 : reader R2 read the number 594
Method [read] finished by thread R2
19:16:07.167 : writer W1 wrote the number 976
19:16:07.667 : writer W1 wrote the number 84
19:16:08.167 : writer W1 wrote the number 970
Method [write] finished by thread W1
19:16:08.671 : reader R1 read the number 976
19:16:09.172 : reader R1 read the number 84
19:16:09.672 : reader R1 read the number 970
Method [read] finished by thread R1
19:16:10.173 : writer W2 wrote the number 54
19:16:10.673 : writer W2 wrote the number 7
19:16:11.174 : writer W2 wrote the number 323
Method [write] finished by thread W2
19:16:11.676 : reader R0 read the number 54
19:16:12.188 : reader R0 read the number 7
19:16:12.700 : reader R0 read the number 323
Method [read] finished by thread R0

El comportamiento es idéntico al del programa anterior: W0, R2, W1, R1, W2, R0.

8.8.5. Varios lectores simultáneos: ReadWriteLock

En los ejemplos anteriores, los lectores eran exclusivos. En muchas aplicaciones, esto es innecesariamente restrictivo: varios hilos pueden leer datos al mismo tiempo mientras nadie los modifica. Solo las escrituras deben ser exclusivas: mientras un escritor modifica los datos, ningún lector ni otro escritor debe poder acceder a ellos. Este es el problema clásico de lectura-escritura, que resuelve la interfaz [java.util.concurrent.locks.ReadWriteLock]. Un objeto [ReadWriteLock] proporciona dos bloqueos vinculados:

  • [readLock()]: el bloqueo de lectura, que puede ser poseído por varios hilos al mismo tiempo, siempre que ningún hilo posea el bloqueo de escritura;
  • [writeLock()]: el bloqueo de escritura, que es exclusivo.

El programa [Threads22.java] es el siguiente:

// varios lectores simultáneos, un único escritor: ReadWriteLock

void main() throws InterruptedException {
    var catalog = new Catalog();
    var threads = new ArrayList<Thread>();
    // tres lectores consultan dos veces el precio del teclado
    for (int i = 0; i < 3; i++) {
        threads.add(Thread.ofPlatform().name("R" + i).start(() -> {
            catalog.read("keyboard");
            catalog.read("keyboard");
        }));
    }
    // un escritor, iniciado 0,5 s después, cambia este precio
    Thread.sleep(500);
    threads.add(Thread.ofPlatform().name("W").start(() -> catalog.modify("keyboard", 25)));
    // espera del fin de todos los hilos
    for (Thread thread : threads) {
        thread.join();
    }
}

// el recurso compartido: un catálogo de precios
static class Catalog {
    private final Map<String, Integer> prices = new HashMap<>(Map.of("keyboard", 20, "mouse", 10));
    // un bloqueo para los lectores, un bloqueo para los escritores
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    // varios hilos pueden tener el bloqueo de lectura al mismo tiempo
    int read(String article) {
        String name = Thread.currentThread().getName();
        lock.readLock().lock();
        try {
            IO.println(time() + " : " + name + " starts reading the price of " + article);
            // lectura larga
            sleep(1000);
            int p = prices.get(article);
            IO.println(time() + " : " + name + " read the price of " + article + " : " + p);
            return p;
        } finally {
            lock.readLock().unlock();
        }
    }

    // el bloqueo de escritura es exclusivo: ningún lector, ningún otro escritor
    void modify(String article, int newPrice) {
        String name = Thread.currentThread().getName();
        IO.println(time() + " : " + name + " requests the write lock");
        lock.writeLock().lock();
        try {
            IO.println(time() + " : " + name + " starts modifying the price of " + article);
            // escritura larga
            sleep(1000);
            prices.put(article, newPrice);
            IO.println(time() + " : " + name + " set the price of " + article + " to " + newPrice);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

Comentarios:

  • líneas 23–59: el recurso compartido es un catálogo de precios, almacenado en un diccionario llamado [HashMap] (línea 24);
  • línea 26: la implementación [ReentrantReadWriteLock] de la interfaz [ReadWriteLock];
  • líneas 29–42: el método [read] adquiere un bloqueo de lectura para una operación de lectura que dura un segundo;
  • líneas 45–58: el método [modify] adquiere el bloqueo de escritura durante una modificación que dura un segundo;
  • líneas 7–12: tres lectores leen dos veces seguidas el precio del teclado;
  • líneas 14–15: un escritor, iniciado medio segundo después, modifica este precio.

Resultados:

> java Threads22.java
19:16:15.988 : R2 starts reading the price of keyboard
19:16:16.000 : R1 starts reading the price of keyboard
19:16:15.984 : R0 starts reading the price of keyboard
19:16:16.461 : W requests the write lock
19:16:17.000 : R1 read the price of keyboard : 20
19:16:16.997 : R2 read the price of keyboard : 20
19:16:17.008 : R0 read the price of keyboard : 20
19:16:17.008 : W starts modifying the price of keyboard
19:16:18.008 : W set the price of keyboard to 25
19:16:18.009 : R0 starts reading the price of keyboard
19:16:18.009 : R2 starts reading the price of keyboard
19:16:18.009 : R1 starts reading the price of keyboard
19:16:19.010 : R2 read the price of keyboard : 25
19:16:19.010 : R1 read the price of keyboard : 25
19:16:19.011 : R0 read the price of keyboard : 25
  • los tres lectores leen al mismo tiempo (líneas 2–4 y 6–8): con un bloqueo estándar, la primera serie de lecturas habría tomado tres segundos en lugar de uno;
  • el escritor, que llegó mientras las lecturas estaban en curso, esperó a que terminaran. Luego cambió el precio él solo;
  • la segunda serie de lecturas, que comenzó después de la llegada del escritor, esperó a que terminara la modificación y luego leyó el nuevo precio. El bloqueo [ReentrantReadWriteLock] impide así que un flujo continuo de lectores bloquee indefinidamente a un escritor: un lector que llega mientras un escritor espera pasa después del escritor. Esta secuencia es reproducible.

Un bloqueo de lectura-escritura solo es útil si las lecturas son numerosas y suficientemente largas. Para lecturas muy breves, la clase [StampedLock] (Java 8) ofrece una lectura “optimista”, sin bloqueo, que se valida después. Y para una colección que se lee con mucha frecuencia pero se modifica rara vez, las colecciones concurrentes descritas en el párrafo siguiente suelen ser la mejor solución.

8.9. Colecciones concurrentes

Los ejemplos anteriores protegían datos compartidos muy simples (un contador, un arreglo, un pequeño diccionario). Cuando los hilos comparten una colección (lista, diccionario, cola), se podría proteger cada acceso con un bloqueo. Sin embargo, las colecciones estándar ([ArrayList], [HashMap], [ArrayDeque]) no están diseñadas para ser modificadas por varios hilos simultáneamente: su uso sin protección puede provocar la pérdida de elementos, desencadenar excepciones inesperadas ([ConcurrentModificationException]) o incluso corromper la estructura interna de la colección. Los métodos [Collections.synchronizedList(…)], [Collections.synchronizedMap(…)]… envuelven una colección normal en un objeto donde cada método es [synchronized]: esto es seguro, pero todos los hilos compiten por un único bloqueo, y la iteración sobre la colección debe seguir protegiéndose manualmente. Desde Java 5, el paquete [java.util.concurrent] ofrece colecciones diseñadas para ser compartidas entre hilos sin un bloqueo explícito:

Colección
Función
[ConcurrentHashMap<K,V>]
Un diccionario cuyas operaciones, incluidas las actualizaciones condicionales ([merge], [compute], [putIfAbsent]…), son seguras y atómicas. Varios hilos pueden leerlo y modificarlo simultáneamente
[ConcurrentSkipListMap<K,V>]
un diccionario ordenado por clave
[CopyOnWriteArrayList<E>]
una lista que copia su arreglo interno con cada modificación: las lecturas y los recorridos, que son muy rápidos, nunca se ven afectados por las modificaciones. Es adecuada para listas que se leen con frecuencia y se modifican rara vez (por ejemplo, listas de reproducción)
[ConcurrentLinkedQueue<E>], [ConcurrentLinkedDeque<E>]
Una cola (primero en entrar, primero en salir), una cola de doble extremo
[BlockingQueue<E>]
una interfaz de cola que bloquea al consumidor cuando la cola está vacía y, si su capacidad es limitada, bloquea al productor cuando está llena. Implementaciones: [ArrayBlockingQueue], [LinkedBlockingQueue], [PriorityBlockingQueue], [SynchronousQueue]…

8.9.1. ConcurrentHashMap y CopyOnWriteArrayList

En el programa [Threads23.java], cuatro hilos generan números aleatorios y cuentan el número de veces que aparece cada número en un diccionario compartido:

// colecciones concurrentes: ConcurrentHashMap y CopyOnWriteArrayList

void main() throws InterruptedException {
    // el diccionario compartido: dígito -> número de sorteos
    var draws = new ConcurrentHashMap<Integer, Integer>();
    // la lista compartida de los informes de los hilos
    var reports = new CopyOnWriteArrayList<String>();

    // 4 hilos sortean cada uno 100.000 dígitos aleatorios
    final int nbDraws = 100_000;
    var threads = new Thread[4];
    for (int i = 0; i < threads.length; i++) {
        threads[i] = Thread.ofPlatform().name("T" + i).start(() -> {
            for (int j = 0; j < nbDraws; j++) {
                int digit = ThreadLocalRandom.current().nextInt(0, 10);
                // se agrega la clave con el valor 1 o se actualiza atómicamente el valor existente
                draws.merge(digit, 1, Integer::sum);
            }
            // informe agregado a la lista
            reports.add("thread %s finished its %,d draws"
                    .formatted(Thread.currentThread().getName(), nbDraws));
        });
    }
    for (Thread thread : threads) {
        thread.join();
    }

    // los informes, en su orden de llegada
    for (String report : reports) {
        IO.println(report);
    }
    // los resultados de los sorteos, en orden de clave
    new TreeMap<>(draws).forEach((digit, count) ->
            IO.println("digit %d : %,6d draws".formatted(digit, count)));
    int total = draws.values().stream().mapToInt(Integer::intValue).sum();
    IO.println("total: %,d draws (expected: %,d)".formatted(total, threads.length * nbDraws));
    // computeIfAbsent: devuelve el valor asociado a la clave, tras calcularlo y agregarlo si es necesario
    IO.println("computeIfAbsent(10, …) = " + draws.computeIfAbsent(10, key -> 0)
            + ", number of keys: " + draws.size());
}

Comentarios:

  • línea 5: el diccionario compartido asocia cada dígito con su número de apariciones;
  • línea 7: una lista donde cada hilo almacena un informe al final de su trabajo;
  • línea 17: el método [merge(key, value, function)] agrega la clave [digit] con el valor 1 si no existe y, en caso contrario, reemplaza su valor v por [function(v, 1)], en este caso la suma [Integer::sum]. En un [ConcurrentHashMap], la operación es atómica. No podríamos escribir [draws.put(digit, draws.get(digit) + 1)]: esta expresión lee el valor y luego escribe el nuevo, en dos operaciones, y dos hilos podrían perder una actualización como en el ejemplo [Threads09.java];
  • línea 20: cada hilo agrega su informe a la lista;
  • líneas 29–31: el hilo principal itera sobre la lista. La iteración sobre una [CopyOnWriteArrayList] se realiza sobre una instantánea del arreglo interno: nunca lanza [ConcurrentModificationException], aunque otros hilos modifiquen la lista durante la iteración;
  • líneas 33–34: el diccionario se copia en un diccionario ordenado [TreeMap] para mostrar los números en orden; el método [forEach] recibe cada par clave/valor;
  • línea 35: la suma de los valores, calculada mediante un stream;
  • línea 38: el método [computeIfAbsent(key, function)] devuelve el valor asociado a la clave, después de calcularlo con la función y agregarlo si la clave no existía. Como con [merge], la verificación y la adición forman una única operación atómica: una verificación con [containsKey] seguida de un [put] no sería segura, ya que otro hilo podría agregar la clave entretanto.

Resultados:

> java Threads23.java
thread T1 finished its 100,000 draws
thread T0 finished its 100,000 draws
thread T2 finished its 100,000 draws
thread T3 finished its 100,000 draws
digit 0 : 40,244 draws
digit 1 : 40,093 draws
digit 2 : 39,719 draws
digit 3 : 40,052 draws
digit 4 : 39,911 draws
digit 5 : 39,687 draws
digit 6 : 39,959 draws
digit 7 : 39,814 draws
digit 8 : 40,235 draws
digit 9 : 40,286 draws
total: 400,000 draws (expected: 400,000)
computeIfAbsent(10, …) = 0, number of keys: 11

El número total de sorteos es correcto: no se perdió ninguna actualización. Los informes aparecen en el orden en que los hilos terminaron su trabajo, que varía de una ejecución a otra.

8.9.2. Productor y consumidores: BlockingQueue

El problema de los lectores y los escritores es una variante del clásico problema productor-consumidor: unos hilos producen datos que otros hilos consumen. La interfaz [BlockingQueue<E>] lo resuelve sin ninguna herramienta de sincronización explícita:

  • [put(element)] agrega un elemento a la cola. Si la cola tiene una capacidad limitada y está llena, el productor queda bloqueado hasta que haya un espacio disponible;
  • [take()] retira el elemento que está al frente de la cola. Si la cola está vacía, el consumidor queda bloqueado hasta que llegue un elemento;
  • [offer(element, timeout, unit)] y [poll(timeout, unit)] hacen lo mismo, con un tiempo máximo de espera; [offer(element)] y [poll()], que no tienen tiempo de espera, nunca bloquean: devuelven [false] o [null] en caso de fallo.

La cola no sabe que la producción ha terminado. Una técnica clásica consiste en colocar en la cola, al final de la producción, un valor especial, conocido en el mundo anglosajón como “poison pill”: el consumidor que lo recupera sabe que debe detenerse. Otra técnica consiste en interrumpir a los consumidores, ya que [take] es interrumpible. El programa [Threads24.java] es el siguiente:

// productor / consumidores con una BlockingQueue

// el valor que señala el fin de la producción ("poison pill")
static final int END = -1;

void main() throws InterruptedException {
    // una cola de 3 elementos como máximo
    BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);
    final int nbConsumers = 2;

    // el productor coloca 8 números y luego señala que ha terminado
    var producer = new Thread(() -> {
        try {
            for (int i = 1; i <= 8; i++) {
                // bloqueante si la cola está llena
                queue.put(i);
                IO.println(time() + " : P put " + i
                        + " (waiting elements: " + queue.size() + ")");
                Thread.sleep(100);
            }
            // un marcador de fin por consumidor
            for (int i = 0; i < nbConsumers; i++) {
                queue.put(END);
            }
            IO.println(time() + " : P has finished");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }, "P");

    // dos consumidores toman los números hasta el marcador de fin
    var consumers = new Thread[nbConsumers];
    for (int i = 0; i < consumers.length; i++) {
        consumers[i] = new Thread(() -> {
            String name = Thread.currentThread().getName();
            try {
                while (true) {
                    // bloqueante si la cola está vacía
                    int number = queue.take();
                    if (number == END) {
                        break;
                    }
                    IO.println(time() + " : " + name + " took " + number);
                    // procesamiento del número
                    Thread.sleep(600);
                }
                IO.println(time() + " : " + name + " has finished");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "C" + (i + 1));
    }

    // inicio de todos los hilos y espera de su fin
    producer.start();
    for (Thread consumer : consumers) {
        consumer.start();
    }
    producer.join();
    for (Thread consumer : consumers) {
        consumer.join();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 4: el valor que marca el fin de la producción. Es una constante, declarada fuera de cualquier clase: es un campo estático de la clase implícita;
  • línea 8: una cola con un máximo de 3 elementos. [ArrayBlockingQueue] almacena los elementos en un arreglo de tamaño fijo; [LinkedBlockingQueue] tiene capacidad ilimitada de forma predeterminada;
  • líneas 12–29: el productor coloca los números del 1 al 8 en la cola, uno cada décima de segundo, seguidos de un marcador de fin para cada consumidor (líneas 22–24);
  • líneas 34–51: dos consumidores recuperan los números y dedican 0,6 segundos a procesar cada uno. Los consumen más lentamente de lo que el productor los genera;
  • línea 39: extracción bloqueante. Cada número es retirado por uno solo de los dos consumidores;
  • líneas 40–42: un consumidor que recupera el marcador de fin sale de su bucle. Cada consumidor recupera uno, de ahí que se deposite un marcador por consumidor;
  • el productor y los consumidores son lambdas que contienen la instrucción [try], porque [put], [take], y [sleep] pueden lanzar [InterruptedException].

Resultados:

> java Threads24.java
19:16:25.299 : P put 1 (waiting elements: 0)
19:16:25.304 : C2 took 1
19:16:25.427 : P put 2 (waiting elements: 1)
19:16:25.428 : C1 took 2
19:16:25.531 : P put 3 (waiting elements: 1)
19:16:25.631 : P put 4 (waiting elements: 2)
19:16:25.732 : P put 5 (waiting elements: 3)
19:16:25.927 : C2 took 3
19:16:25.927 : P put 6 (waiting elements: 3)
19:16:26.028 : C1 took 4
19:16:26.029 : P put 7 (waiting elements: 3)
19:16:26.528 : C2 took 5
19:16:26.528 : P put 8 (waiting elements: 3)
19:16:26.652 : C1 took 6
19:16:27.128 : P has finished
19:16:27.129 : C2 took 7
19:16:27.253 : C1 took 8
19:16:27.736 : C2 has finished
19:16:27.854 : C1 has finished

Vemos que el productor agrega rápidamente los primeros números y que, en cuanto la cola contiene 3 elementos, solo agrega un número cuando un consumidor retira uno: queda bloqueado por [put] cuando la cola está llena. Los consumidores se reparten los números y se detienen cuando retiran el marcador de fin. Este ritmo es reproducible; la asignación de cada número a C1 o C2 no lo es. El productor muestra “P has finished” solo después de que sus dos marcadores de fin han sido colocados, es decir, después de que C2 haya retirado el número 7 y liberado un espacio.

Volveremos a las colas bloqueantes en el próximo capítulo, al hablar de la transferencia de datos entre procesos asíncronos. Con hilos virtuales, un consumidor bloqueado en [take] no ocupa ningún hilo del sistema.

8.10. Pools de hilos: ExecutorService

8.10.1. El principio

Hasta ahora, para administrar hilos, los hemos creado y luego iniciado mediante [start()]. Crear un hilo de plataforma es una operación relativamente costosa: en particular, el sistema debe asignarle una pila, y cada hilo ocupa memoria mientras exista. Veremos en el capítulo 10 que existen pools de conexiones: las conexiones abiertas se mantienen en reserva y se prestan a los hilos que las solicitan, ya que abrir una conexión es costoso. Existe un sistema similar para los hilos: el pool de hilos.

Java representa un pool de hilos mediante la interfaz [java.util.concurrent.ExecutorService] (un “ejecutor”): ya no se crean hilos; en su lugar, se asignan tareas al ejecutor, que hace que sus hilos las ejecuten. Un hilo que ha completado una tarea no se destruye; pasa a la siguiente tarea. La clase [ThreadPoolExecutor], la implementación más común, funciona de la siguiente manera:

  • tiene un número fijo de hilos (“core pool size”): mientras no se haya alcanzado este número, cada nueva tarea provoca la creación de un nuevo hilo;
  • una vez superado, las tareas se colocan en una cola (una [BlockingQueue]) de la que los hilos las recuperan;
  • si la cola está llena, el pool crea hilos adicionales, hasta un número máximo (“maximum pool size”). Estos hilos adicionales se destruyen si permanecen inactivos durante más de cierto tiempo;
  • si se alcanza el máximo y la cola está llena, la tarea es rechazada: de forma predeterminada, el método que la envió lanza la excepción [RejectedExecutionException].

El pool de hilos ofrece dos ventajas: ahorra el tiempo dedicado a crear hilos (unos pocos hilos pueden atender cientos de solicitudes) y, al limitar el número de hilos, evita que la aplicación se vea desbordada por demasiadas solicitudes.

Un ejecutor termina mediante su método [shutdown] (deja de aceptar nuevas tareas y sus hilos se detienen una vez completadas las tareas ya enviadas), seguido opcionalmente de [awaitTermination] (que espera a que las tareas terminen), o mediante [shutdownNow] (que interrumpe las tareas en curso). A partir de Java 19, [ExecutorService] extiende la interfaz [AutoCloseable]: su método [close] llama a [shutdown] y luego espera a que todas las tareas terminen. Por lo tanto, se puede declarar un ejecutor en una instrucción [try] con recurso: al salir del bloque, todas las tareas asignadas están completadas. El programa [Threads25.java] es el siguiente:

// un grupo de hilos: ThreadPoolExecutor

void main() {
    Thread.currentThread().setName("Main");
    // 3 hilos permanentes, como máximo 5 hilos, una cola de espera de 2 trabajos
    try (var pool = new ThreadPoolExecutor(3, 5, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2))) {
        // se entregan 8 trabajos de 3 s al grupo
        for (int i = 0; i < 8; i++) {
            var data = new Data(i, LocalTime.now(), 3);
            try {
                pool.execute(() -> sleep(data, pool));
            } catch (RejectedExecutionException e) {
                IO.println(time() + " : job no. " + i + " was rejected by the pool");
            }
        }
        IO.println(time() + " : thread Main gave the jobs to the pool and waits for their end");
        // el fin del bloque try cierra el grupo: close() espera el fin de los trabajos enviados
    }
    IO.println(time() + " : end of thread Main");
}

// el trabajo ejecutado por un hilo del grupo
static void sleep(Data data, ThreadPoolExecutor pool) {
    // estado del grupo
    IO.println("%s : job no. %d starts in thread %s (threads: %d, active: %d, queued: %d)"
            .formatted(time(), data.number(), Thread.currentThread().getName(),
                    pool.getPoolSize(), pool.getActiveCount(), pool.getQueue().size()));
    // espera de [duration] segundos
    try {
        Thread.sleep(data.duration() * 1000L);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    double duration = Duration.between(data.start(), LocalTime.now()).toMillis() / 1000.0;
    IO.println("%s : job no. %d ends: scheduled for %d s, it lasted %.2f s since its request"
            .formatted(time(), data.number(), data.duration(), duration));
}

// la información pasada a cada trabajo
record Data(int number, LocalTime start, int duration) {
}

// la hora actual, a la centésima de segundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SS"));
}

Comentarios:

  • línea 6: el pool tiene 3 hilos permanentes, con un máximo de 5 hilos; cualquier hilo adicional que haya estado inactivo durante 60 segundos se destruye; la cola de tareas es una [ArrayBlockingQueue] de 2 plazas. El pool se crea en una instrucción [try] con recurso;
  • líneas 8–15: se asignan 8 trabajos al pool, cada uno de los cuales dura 3 segundos. El método [execute(Runnable)] asigna una tarea al pool sin esperar;
  • línea 9: cada trabajo recibe un objeto [Data]; este es un [record] (línea 40), que también está definido fuera de cualquier clase;
  • líneas 12–14: un trabajo rechazado por el pool provoca la excepción [RejectedExecutionException];
  • línea 18: al salir del bloque [try] se cierra el pool y se espera a que terminen los trabajos asignados;
  • líneas 23–37: el trabajo ejecutado por un hilo del pool. Los nombres de los hilos ([pool-1-thread-1]…) los proporciona el pool;
  • línea 27: el estado del pool: el número de sus hilos ([getPoolSize]), el número de hilos que están ejecutando un trabajo en ese momento ([getActiveCount]) y el número de trabajos que esperan en la cola ([getQueue().size()]);
  • línea 45: las horas se muestran con precisión de centésimas de segundo ([SS]).

Resultados:

> java Threads25.java
19:16:31.71 : job no. 7 was rejected by the pool
19:16:31.72 : thread Main gave the jobs to the pool and waits for their end
19:16:31.62 : job no. 1 starts in thread pool-1-thread-2 (threads: 2, active: 2, queued: 0)
19:16:31.72 : job no. 2 starts in thread pool-1-thread-3 (threads: 5, active: 5, queued: 2)
19:16:31.72 : job no. 6 starts in thread pool-1-thread-5 (threads: 5, active: 5, queued: 2)
19:16:31.71 : job no. 5 starts in thread pool-1-thread-4 (threads: 5, active: 5, queued: 2)
19:16:31.62 : job no. 0 starts in thread pool-1-thread-1 (threads: 2, active: 2, queued: 0)
19:16:34.81 : job no. 2 ends: scheduled for 3 s, it lasted 3.10 s since its request
19:16:34.81 : job no. 3 starts in thread pool-1-thread-3 (threads: 5, active: 5, queued: 1)
19:16:34.82 : job no. 5 ends: scheduled for 3 s, it lasted 3.10 s since its request
19:16:34.82 : job no. 4 starts in thread pool-1-thread-4 (threads: 5, active: 5, queued: 0)
19:16:34.82 : job no. 6 ends: scheduled for 3 s, it lasted 3.10 s since its request
19:16:34.82 : job no. 0 ends: scheduled for 3 s, it lasted 3.21 s since its request
19:16:34.82 : job no. 1 ends: scheduled for 3 s, it lasted 3.20 s since its request
19:16:37.82 : job no. 4 ends: scheduled for 3 s, it lasted 6.10 s since its request
19:16:37.81 : job no. 3 ends: scheduled for 3 s, it lasted 6.10 s since its request
19:16:37.82 : end of thread Main
  • los trabajos 0, 1 y 2 fueron asignados a los tres hilos permanentes creados para ese fin;
  • los trabajos 3 y 4 se colocaron en la cola, que ahora está llena;
  • los trabajos 5 y 6 provocaron la creación de dos hilos adicionales ([pool-1-thread-4] y [pool-1-thread-5]): comenzaron de inmediato, antes que los trabajos 3 y 4, que esperaban en la cola. Esta es la regla de [ThreadPoolExecutor]: primero la cola y luego los hilos adicionales, lo cual a menudo resulta sorprendente;
  • el trabajo 7 fue rechazado: 5 hilos ocupados, cola llena;
  • los trabajos 3 y 4 tuvieron que esperar a que un hilo quedara disponible después de que terminaran los primeros trabajos: reutilizaron los hilos 3 y 4. En total, tardaron un poco más de 6 segundos desde su solicitud: 3 segundos de espera y 3 segundos de procesamiento;
  • Los valores que muestra cada tarea al iniciarse (número de hilos, cola) dependen del momento exacto en que obtuvo el procesador: varían de una ejecución a otra. Sin embargo, el resultado de cada tarea (ejecución inmediata, espera en la cola o rechazo) es reproducible.

Rara vez se construye un *[ThreadPoolExecutor] directamente: la clase *[Executors] ofrece métodos de construcción para los casos comunes:

Método
Executor devuelto
[newFixedThreadPool(n)]
un pool de n hilos permanentes, con una cola de capacidad ilimitada
[newCachedThreadPool()]
un pool sin hilos permanentes, que crea tantos hilos como sean necesarios y destruye los que permanecen inactivos durante 60 segundos
[newSingleThreadExecutor()]
un único hilo que ejecuta las tareas una tras otra, en el orden en que se enviaron
[newScheduledThreadPool(n)]
Un pool capaz de ejecutar tareas después de un retraso o de forma periódica (interfaz [ScheduledExecutorService])
[newVirtualThreadPerTaskExecutor()]
(Java 21) un executor sin pool, que crea un nuevo hilo virtual para cada tarea

El último executor merece una aclaración: los hilos virtuales no se colocan en un pool. Son tan económicos que se crea uno nuevo para cada tarea; para limitar el uso de recursos se emplea un semáforo, como en el programa [Threads15.java].

8.10.2. Tareas con resultado: Callable y Future

El método [execute] pasa un [Runnable] al pool, que no devuelve ningún resultado. El método [submit(task)] también acepta un [Callable<V>], una interfaz funcional cuyo método [V call() throws Exception] devuelve un resultado de tipo V y puede lanzar excepciones verificadas. Devuelve un objeto [Future<V>] que permite dar seguimiento a la tarea:

Método de Future<V>
Función
[V get()], [V get(long timeout, TimeUnit unit)]
espera a que la tarea termine (como máximo durante el tiempo indicado en [timeout]) y devuelve su resultado. Si la tarea lanza una excepción, [get] lanza una [ExecutionException] que la encapsula (método [getCause])
[boolean isDone()]
indica si la tarea ha terminado (normalmente, por una excepción o por cancelación)
[Future.State state()]
(Java 19) el estado de la tarea: [RUNNING], [SUCCESS], [FAILED], o [CANCELLED]
[V resultNow()], [Throwable exceptionNow()]
(Java 19) el resultado o la excepción de una tarea que ya ha terminado, sin esperar
[boolean cancel(boolean mayInterruptIfRunning)]
cancela la tarea; si ya se inició y [mayInterruptIfRunning] es igual a [true], se interrumpe el hilo que la ejecuta

El método [invokeAll(collection of Callable)] del executor envía todas las tareas de una colección, espera a que todas terminen y devuelve la lista de sus valores [Future] , en el orden de la colección. El método [invokeAny] devuelve el resultado de la primera tarea que termina con éxito y cancela las demás. El programa [Threads26.java] es el siguiente:

// ExecutorService: envío de tareas y obtención de su resultado con Future

void main() throws InterruptedException {
    IO.println("Main thread: " + Thread.currentThread());

    // 1 - un grupo de 2 hilos, cerrado automáticamente al final del bloque try
    try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
        // tres tareas que devuelven cada una un resultado de tipo Integer
        var futures = new ArrayList<Future<Integer>>();
        for (int i = 0; i < 3; i++) {
            int number = i;
            futures.add(pool.submit(() -> {
                IO.println(time() + " : task " + number + " runs in thread "
                        + Thread.currentThread().getName());
                // trabajo: un Callable puede lanzar excepciones verificadas
                Thread.sleep(500L * (number + 1));
                // el resultado de la tarea
                return number * 10;
            }));
        }
        // los resultados: get() espera el fin de la tarea
        for (int i = 0; i < futures.size(); i++) {
            Future<Integer> future = futures.get(i);
            try {
                IO.println("task " + i + " : result " + future.get() + ", state " + future.state());
            } catch (ExecutionException e) {
                IO.println("task " + i + " failed: " + e.getCause());
            }
        }

        // una tarea que lanza una excepción
        Future<Integer> failing = pool.submit(() -> fail());
        try {
            failing.get();
        } catch (ExecutionException e) {
            // la excepción de la tarea se envuelve en una ExecutionException
            IO.println(e.getClass().getSimpleName() + " containing " + e.getCause().getClass().getSimpleName()
                    + " : " + e.getCause().getMessage());
        }
        IO.println("failing task: state " + failing.state());
    }

    // 2 - un hilo virtual por tarea; invokeAll envía una colección de tareas y espera su fin
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        List<Callable<String>> jobs = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            int number = i;
            jobs.add(() -> {
                Thread.sleep(300);
                return "job " + number + " executed by " + Thread.currentThread();
            });
        }
        for (Future<String> future : executor.invokeAll(jobs)) {
            // la tarea ha terminado: resultNow() devuelve su resultado sin esperar
            IO.println(future.resultNow());
        }
    }
}

// el trabajo de la tarea que falla
static int fail() {
    throw new IllegalStateException("test....");
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • línea 7: un pool de 2 hilos, creado con [Executors.newFixedThreadPool(2)] y cerrado al final del bloque [try];
  • líneas 12–19: cada tarea es una lambda que muestra el hilo que la ejecuta, espera 0,5, 1 o 1,5 segundos y luego devuelve un resultado entero. Como la lambda devuelve un valor, el compilador la interpreta como un [Callable<Integer>], y [submit] produce un [Future<Integer>]. El [sleep] de la línea 16 no necesita estar encerrado en un [try]: el método [call] de [Callable] declara [throws Exception];
  • línea 25: [future.get()] espera a que la tarea termine y devuelve su resultado; [future.state()] devuelve su estado;
  • línea 32: una tarea que ejecuta el método [fail] (líneas 61–63), que lanza una excepción;
  • líneas 34–38: la excepción lanzada en la tarea no se pierde: se almacena en el objeto [Future] y luego se vuelve a lanzar en el hilo que solicita el resultado, encapsulada en una [ExecutionException] cuyo método [getCause] devuelve la excepción original;
  • líneas 44–57: un executor que crea un hilo virtual por tarea. El método [invokeAll] (línea 53) le asigna las tres tareas de la lista [jobs] y espera a que terminen. Una vez completadas las tareas, [resultNow] (línea 55) devuelve sus resultados de inmediato.

Resultados:

> java Threads26.java
Main thread: Thread[#3,main,5,main]
19:16:39.815 : task 0 runs in thread pool-1-thread-1
19:16:39.816 : task 1 runs in thread pool-1-thread-2
19:16:40.333 : task 2 runs in thread pool-1-thread-1
task 0 : result 0, state SUCCESS
task 1 : result 10, state SUCCESS
task 2 : result 20, state SUCCESS
ExecutionException containing IllegalStateException : test....
failing task: state FAILED
job 0 executed by VirtualThread[#25]/runnable@ForkJoinPool-1-worker-1
job 1 executed by VirtualThread[#27]/runnable@ForkJoinPool-1-worker-2
job 2 executed by VirtualThread[#30]/runnable@ForkJoinPool-1-worker-1
  • las tareas se ejecutan en los hilos del pool ([pool-1-thread-1] y [pool-1-thread-2]);
  • la tarea 2 no se inició hasta que la tarea 0 terminó, en el hilo que esta liberó: el pool solo tiene 2 hilos y la tarea 2 esperó en la cola. Este problema es reproducible;
  • los resultados se recuperan una vez finalizadas las tareas, y su estado es [SUCCESS];
  • el hilo principal capturó la excepción de la tarea que falló, y el estado de la tarea es [FAILED];
  • las tres tareas de la segunda parte fueron ejecutadas por tres hilos virtuales distintos, montados sobre los hilos portadores [ForkJoinPool-1-worker-1] y [ForkJoinPool-1-worker-2].

Bloquear un hilo en [get] para esperar un resultado es sencillo, pero no permite encadenar operaciones de procesamiento a la finalización de una tarea sin esperar. La clase [CompletableFuture], presentada en el capítulo siguiente, lo permite. Por último, tenga en cuenta que Java 25 ofrece, como versión preliminar, la concurrencia estructurada ([StructuredTaskScope]), que trata un grupo de subtareas como una única unidad de trabajo (si una falla, las demás se abortan); como aún no es definitiva, no se utiliza en este curso.

8.11. Paralelismo de datos

8.11.1. Streams paralelos

Volvamos al primer uso de los hilos: aprovechar todos los procesadores para un cálculo que consume mucho tiempo. Los streams de la API Stream (capítulo 5) pueden ejecutarse en paralelo: basta con llamar a [parallel()] sobre un stream, o a [parallelStream()] en lugar de [stream()] sobre una colección. El stream divide entonces los datos en fragmentos, hace que varios hilos procesen los fragmentos y después combina los resultados parciales. Los hilos utilizados son los del pool compartido ([ForkJoinPool.commonPool()]), al que se suma el hilo que ejecuta el stream. De forma predeterminada, el pool compartido tiene tantos hilos como procesadores, menos uno: el hilo que realiza la llamada también participa en el conteo.

Estos streams solo son adecuados si el procesamiento de cada elemento es independiente de los demás: el orden de procesamiento no está definido y, si el procesamiento actualiza datos compartidos, estos deben protegerse. El programa [Threads27.java] es el siguiente:

// streams paralelos: parallelStream e IntStream.parallel

void main() {
    // 1 - conteo de los números primos menores que N
    final int N = 5_000_000;
    // versión secuencial: un bucle for
    long start = System.nanoTime();
    int nbSequential = 0;
    for (int i = 2; i < N; i++) {
        if (isPrime(i)) {
            nbSequential++;
        }
    }
    IO.println("sequential for       : %,d prime numbers in %d ms"
            .formatted(nbSequential, since(start)));

    // versión secuencial: un stream
    start = System.nanoTime();
    long nbStream = IntStream.range(2, N).filter(i -> isPrime(i)).count();
    IO.println("sequential stream    : %,d prime numbers in %d ms".formatted(nbStream, since(start)));

    // versión paralela: el mismo stream, hecho paralelo
    start = System.nanoTime();
    long nbParallel = IntStream.range(2, N).parallel().filter(i -> isPrime(i)).count();
    IO.println("parallel stream      : %,d prime numbers in %d ms".formatted(nbParallel, since(start)));

    // los hilos que trabajaron y el número de números primos encontrados por cada uno
    var threads = new ConcurrentHashMap<String, Integer>();
    IntStream.range(2, N).parallel()
            .filter(i -> isPrime(i))
            .forEach(i -> threads.merge(Thread.currentThread().getName(), 1, Integer::sum));
    new TreeMap<>(threads).forEach((name, nb) ->
            IO.println("  thread %-30s : %,d prime numbers found".formatted(name, nb)));

    // 2 - procesamiento de una colección en paralelo
    List<String> files = List.of("a.txt", "b.txt", "c.txt", "d.txt", "e.txt");
    files.parallelStream().forEach(file -> {
        IO.println(time() + " : processing of " + file + " in thread "
                + Thread.currentThread().getName());
        // procesamiento simulado
        sleep(500);
    });
    IO.println("parallel forEach finished");
    IO.println("Parallelism of the common pool: " + ForkJoinPool.getCommonPoolParallelism());
}

// prueba de primalidad (deliberadamente simple)
static boolean isPrime(int n) {
    if (n < 2) {
        return false;
    }
    for (int d = 2; d * d <= n; d++) {
        if (n % d == 0) {
            return false;
        }
    }
    return true;
}

// el número de milisegundos transcurridos desde [start] (en nanosegundos)
static long since(long start) {
    return (System.nanoTime() - start) / 1_000_000;
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// la hora actual, al milisegundo
static String time() {
    return LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
}

Comentarios:

  • líneas 7–15: se cuentan los números primos menores que 5.000.000 mediante un bucle [for] estándar. La función [isPrime] (líneas 48–58) prueba los divisores hasta la raíz cuadrada del número: es un proceso que consume mucho tiempo y las iteraciones son independientes;
  • líneas 18–20: el mismo cálculo mediante un flujo secuencial: [IntStream.range(2, N)] genera los enteros de 2 a N–1, [filter] conserva solo los números primos y [count] los cuenta;
  • líneas 23–25: el mismo stream, hecho paralelo mediante [parallel()]. No es necesario cambiar nada más: cada hilo cuenta los números primos de sus segmentos y el stream suma los conteos parciales. No se comparten datos entre los hilos;
  • líneas 28–33: para determinar qué hilos han completado su trabajo, el stream paralelo cuenta, por cada hilo, los números primos que ha encontrado y los almacena en un [ConcurrentHashMap] compartido. Se trata de datos compartidos, actualizados mediante una operación atómica ([merge]);
  • líneas 36–42: el método ***[parallelStream()], que recibe una lista de nombres de archivo, devuelve un stream paralelo; *[forEach] procesa cada archivo (el procesamiento se simula con una pausa de medio segundo). Con un stream paralelo, [forEach] no conserva el orden de la lista; [forEachOrdered] lo conservaría, a costa de parte del paralelismo;
  • Línea 44: el número de hilos del pool compartido.

Resultados:

> java Threads27.java
sequential for       : 348,513 prime numbers in 1419 ms
sequential stream    : 348,513 prime numbers in 1253 ms
parallel stream      : 348,513 prime numbers in 780 ms
  thread ForkJoinPool.commonPool-worker-1 : 224,082 prime numbers found
  thread main                           : 124,431 prime numbers found
19:16:47.328 : processing of b.txt in thread ForkJoinPool.commonPool-worker-1
19:16:47.328 : processing of c.txt in thread main
19:16:47.838 : processing of a.txt in thread ForkJoinPool.commonPool-worker-1
19:16:47.838 : processing of e.txt in thread main
19:16:48.339 : processing of d.txt in thread ForkJoinPool.commonPool-worker-1
parallel forEach finished
Parallelism of the common pool: 1
  • Las tres versiones encuentran la misma cantidad de números primos;
  • dos hilos participaron en el procesamiento paralelo: el hilo [main] y el único hilo del pool compartido ([ForkJoinPool.commonPool-worker-1]): en esta máquina de dos procesadores, el pool compartido solo tiene un hilo (línea 13);
  • el procesamiento de los archivos se realiza de dos en dos, con medio segundo de diferencia, y en un orden que no coincide con el de la lista;
  • el stream paralelo fue más rápido, pero no el doble de rápido: los hilos de nuestro programa compartían los dos procesadores con otros programas muy activos en el momento de la captura, y los tiempos medidos variaron considerablemente de una ejecución a otra. En una máquina con poca carga y n procesadores, un stream paralelo como este puede ser casi n veces más rápido que el stream secuencial. Mida siempre antes de sacar conclusiones: la paralelización tiene un costo (partición del trabajo, sincronización, combinación de resultados) que solo vale la pena si el procesamiento de cada elemento requiere una cantidad significativa de cálculo.

8.11.2. Divide y vencerás: ForkJoinPool y RecursiveTask

Los streams paralelos se basan en el framework Fork/Join (Java 7), que también puede utilizarse directamente. Es muy adecuado para algoritmos de «divide y vencerás»: una tarea demasiado grande se descompone en subtareas, que a su vez se descomponen, hasta que los fragmentos son lo bastante pequeños para procesarse directamente; luego se combinan los resultados de las subtareas. Una tarea es una clase derivada de [RecursiveTask<V>] (una tarea que devuelve un resultado de tipo V) o de [RecursiveAction] (sin resultado), en la que se redefine el método [compute]. En [compute], el método [fork()] de una subtarea la envía de inmediato al pool, y su método [join()] espera su resultado.

Las tareas son ejecutadas por un [ForkJoinPool], en el que cada hilo tiene su propia cola de tareas. Un hilo que se queda sin trabajo «roba» tareas de la cola de otro hilo («work stealing»): de este modo la carga se distribuye automáticamente. Los hilos portadores de los hilos virtuales también forman un [ForkJoinPool]: es el que vimos en la representación textual de los hilos virtuales ([ForkJoinPool-1-worker-1]). El programa [Threads28.java] cuenta números primos mediante una tarea recursiva:

// divide y vencerás: ForkJoinPool y RecursiveTask

void main() {
    final int N = 5_000_000;
    // el grupo común, usado por defecto por los streams paralelos
    long start = System.nanoTime();
    int nb = ForkJoinPool.commonPool().invoke(new CountPrimes(2, N));
    IO.println("common pool       : %,d prime numbers in %d ms".formatted(nb, since(start)));

    // un grupo de 4 hilos, cerrado al final del bloque try
    try (var pool = new ForkJoinPool(4)) {
        CountPrimes.chunks.clear();
        start = System.nanoTime();
        nb = pool.invoke(new CountPrimes(2, N));
        IO.println("pool of 4 threads : %,d prime numbers in %d ms".formatted(nb, since(start)));
        IO.println("tasks stolen by one thread from another: " + pool.getStealCount());
    }
    // la distribución de los fragmentos entre los hilos del último grupo
    new TreeMap<>(CountPrimes.chunks).forEach((name, nbChunks) ->
            IO.println("  %-25s : %d chunks processed".formatted(name, nbChunks)));
}

// una tarea que cuenta los números primos del intervalo [start, end[
static class CountPrimes extends RecursiveTask<Integer> {
    @Serial
    private static final long serialVersionUID = 1L;
    // por debajo de este umbral, el fragmento se procesa directamente
    private static final int THRESHOLD = 100_000;
    // el número de fragmentos procesados por cada hilo
    static final Map<String, Integer> chunks = new ConcurrentHashMap<>();

    private final int start;
    private final int end;

    CountPrimes(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        // fragmento suficientemente pequeño: se procesa de forma secuencial
        if (end - start <= THRESHOLD) {
            chunks.merge(Thread.currentThread().getName(), 1, Integer::sum);
            int nb = 0;
            for (int i = start; i < end; i++) {
                if (isPrime(i)) {
                    nb++;
                }
            }
            return nb;
        }
        // de lo contrario, se divide en dos
        int middle = (start + end) >>> 1;
        var left = new CountPrimes(start, middle);
        var right = new CountPrimes(middle, end);
        // la mitad izquierda se entrega al grupo (otro hilo puede "robarla")
        left.fork();
        // la mitad derecha la procesa el hilo actual
        int nbRight = right.compute();
        // se espera el resultado de la mitad izquierda y se combinan los dos resultados
        return left.join() + nbRight;
    }
}

// prueba de primalidad (deliberadamente simple)
static boolean isPrime(int n) {
    if (n < 2) {
        return false;
    }
    for (int d = 2; d * d <= n; d++) {
        if (n % d == 0) {
            return false;
        }
    }
    return true;
}

// el número de milisegundos transcurridos desde [start] (en nanosegundos)
static long since(long start) {
    return (System.nanoTime() - start) / 1_000_000;
}

Comentarios:

  • líneas 24–64: la tarea [CountPrimes] cuenta los números primos en el intervalo [start, end[. Deriva de [RecursiveTask<Integer>];
  • líneas 25–26: las tareas Fork/Join son serializables: la opción del compilador [-Xlint:all] exige, por tanto, declarar el número de versión de serialización [serialVersionUID], con la anotación [@Serial] (Java 14);
  • línea 28: para menos de 100.000 números, un intervalo se procesa directamente;
  • línea 30: por cada hilo, el número de fragmentos que ha procesado;
  • líneas 43–52: un fragmento suficientemente pequeño se procesa de forma secuencial;
  • líneas 54–56: un fragmento demasiado grande se divide en dos subtareas. La expresión [(start + end) >>> 1] calcula el valor medio mediante un desplazamiento a la derecha sin signo, lo que evita un desbordamiento si la suma supera la capacidad de un [int];
  • línea 58: la mitad izquierda se asigna al pool; otro hilo puede «robarla»;
  • línea 60: la mitad derecha la procesa el hilo actual mediante una llamada directa a [compute]. No es necesario asignar ambas mitades al pool: el hilo actual no tendría nada más que hacer que esperar;
  • línea 62: el hilo espera el resultado de la mitad izquierda (que procesará él mismo si nadie la ha «robado») y combina los dos resultados;
  • línea 7: la tarea se ejecuta primero en el pool compartido. El método [invoke(task)] envía la tarea y espera su resultado;
  • líneas 11–17: luego en un pool de 4 hilos, creado en una instrucción [try] con recurso ([ForkJoinPool] es un [ExecutorService]). El método [getStealCount] devuelve el número de tareas que un hilo ha robado a otro;
  • líneas 19–20: la distribución de los fragmentos entre los hilos de este pool.

Resultados:

1
2
3
4
5
6
7
8
> java Threads28.java
common pool       : 348,513 prime numbers in 1506 ms
pool of 4 threads : 348,513 prime numbers in 648 ms
tasks stolen by one thread from another: 6
  ForkJoinPool-1-worker-1   : 15 chunks processed
  ForkJoinPool-1-worker-2   : 19 chunks processed
  ForkJoinPool-1-worker-3   : 12 chunks processed
  ForkJoinPool-1-worker-4   : 18 chunks processed
  • el pool compartido no fue más rápido que un bucle secuencial (compárelo con el programa anterior): en esta máquina solo tiene un hilo, y el hilo principal —que espera el resultado en [invoke]— no participa en el cálculo como lo hace en un stream paralelo;
  • el pool de 4 hilos aprovechó los dos procesadores y fue aproximadamente el doble de rápido. Tener más hilos que procesadores no ofrece ningún beneficio en un cálculo puro, pero aquí no cuesta mucho;
  • Los 64 fragmentos (5.000.000 / 100.000, redondeado a la siguiente potencia de 2 debido a las divisiones por la mitad) se distribuyeron de forma aproximadamente equitativa entre los 4 hilos, gracias al robo de tareas. Esta distribución varía de una ejecución a otra.

Los streams paralelos son suficientes en la mayoría de los casos; una tarea Fork/Join solo se escribe para un algoritmo recursivo que no puede expresarse fácilmente como un stream (ordenación, recorrido de árboles, etc.).

8.12. Datos locales al hilo

8.12.1. El principio

Consideremos una aplicación de tres capas:

Image

Supongamos que la aplicación es multiusuario, como una aplicación web. Cada solicitud de usuario es atendida por un hilo. El ciclo de vida del hilo es el siguiente:

  • el hilo se crea (hilo virtual) o se solicita a un pool de hilos para atender la solicitud de un usuario;
  • si esta solicitud requiere datos, el hilo ejecuta un método de la capa [ui], que llama a un método de la capa [business], que a su vez llama a un método de la capa [dao];
  • el hilo devuelve la respuesta al usuario. Luego, o bien termina, o bien se devuelve al pool de hilos.

Durante el segundo paso, puede ser útil que el hilo tenga sus propios datos, es decir, datos no compartidos con otros hilos. Estos datos podrían, por ejemplo, pertenecer al usuario específico al que atiende el hilo y utilizarse en las distintas capas [ui, business, dao] sin pasarlos como parámetro a cada método.

Java ofrece dos herramientas para este fin:

  • La clase [ThreadLocal<T>] (Java 1.2): un objeto cuyo valor —leído con [get()] y escrito con [set(value)]— es diferente para cada hilo. El constructor [ThreadLocal.withInitial(supplier)] proporciona el valor inicial para cada hilo; el método [remove()] borra el valor del hilo actual. La clase derivada [InheritableThreadLocal<T>] transmite el valor que tiene el hilo creador al hilo recién creado;
  • la clase [ScopedValue<T>] (definitiva en Java 25): un valor enlazado, durante un ámbito delimitado del código, a un hilo, y que no puede modificarse dentro de ese ámbito.

8.12.2. La clase ThreadLocal

El programa [Threads29.java] compara un campo estático normal, un [ThreadLocal], y un [InheritableThreadLocal]:

// datos locales al hilo: ThreadLocal e InheritableThreadLocal

void main() throws InterruptedException {
    Thread.currentThread().setName("Main");
    // el hilo principal escribe sus propios valores
    Context.shared = 100;
    Context.perThread.set(100);
    Context.user.set("admin");
    Context.language.set("fr");

    // tres hilos escriben y luego releen los datos
    var threads = new Thread[3];
    for (int i = 0; i < threads.length; i++) {
        int number = i;
        threads[i] = new Thread(() -> {
            // escritura
            Context.shared = number;
            Context.perThread.set(number);
            // el hilo T2 no establece ningún usuario: tendrá el valor inicial
            if (number != 2) {
                Context.user.set("user" + number);
            }
            // el hilo T1 cambia el idioma heredado del hilo principal
            if (number == 1) {
                Context.language.set("en");
            }
            // se deja que los demás hilos escriban por turnos
            sleep(200);
            // relectura
            display();
        }, "T" + i);
        threads[i].start();
    }
    for (Thread thread : threads) {
        thread.join();
    }
    // relectura por el hilo principal
    display();
}

// muestra los datos vistos por el hilo actual
static void display() {
    IO.println("%-4s : shared=%-3d perThread=%-3d user=%-20s language=%s".formatted(
            Thread.currentThread().getName(), Context.shared, Context.perThread.get(),
            Context.user.get(), Context.language.get()));
}

// los datos del programa
static class Context {
    // un campo static (volatile): una única copia, compartida por todos los hilos
    static volatile int shared;
    // una copia por hilo; valor inicial null
    static final ThreadLocal<Integer> perThread = new ThreadLocal<>();
    // una copia por hilo, inicializada para cada hilo por la fábrica suministrada
    static final ThreadLocal<String> user =
            ThreadLocal.withInitial(() -> "anonymous (thread " + Thread.currentThread().getName() + ")");
    // una copia por hilo, cuyo valor inicial se hereda del hilo creador
    static final InheritableThreadLocal<String> language = new InheritableThreadLocal<>();
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

Comentarios:

  • línea 51: un campo estático normal. Solo existe una instancia, compartida por todos los hilos. Es [volatile], para que cada hilo vea el último valor escrito por los demás;
  • línea 53: un objeto [ThreadLocal<Integer>]. Cada hilo tiene su propio valor; mientras un hilo no haya escrito en él, [get] devuelve [null];
  • líneas 55–56: un objeto [ThreadLocal<String>] creado mediante [ThreadLocal.withInitial(…)]. La lambda pasada a este método se ejecuta la primera vez que un hilo lee el valor sin haberlo escrito; proporciona el valor inicial para ese hilo;
  • línea 58: un objeto [InheritableThreadLocal<String>]: cuando se crea un hilo, su valor inicial es una copia del valor que tenía el hilo creador en ese momento;
  • líneas 6–9: el hilo principal escribe sus propios valores;
  • líneas 17–26: cada hilo escribe sus propios valores, excepto el hilo T2, que no establece un usuario, y el hilo T1, que es el único que cambia el idioma;
  • línea 28: cada hilo espera a que los demás escriban antes de volver a leer los valores;
  • líneas 42–46: se muestran los datos vistos por el hilo actual.

Resultados:

1
2
3
4
5
> java Threads29.java
T1   : shared=2   perThread=1   user=user1                language=en
T0   : shared=2   perThread=0   user=user0                language=fr
T2   : shared=2   perThread=2   user=anonymous (thread T2) language=fr
Main : shared=2   perThread=100 user=admin                language=fr
  • el campo ordinario [shared] tiene el mismo valor para todos los hilos: el último valor escrito (en esta ejecución, el del hilo T2; otra ejecución puede dar un valor distinto);
  • [perThread] ha conservado, en cada hilo, el valor que ese hilo escribió en él;
  • [user] tiene el valor escrito por cada hilo; el hilo T2, que no había escrito en él, obtuvo el valor inicial proporcionado por la lambda de [withInitial];
  • [language] es igual a [fr] para los hilos T0 y T2, que lo heredaron del hilo principal sin escribir nunca en él. El hilo T1 lo cambió a [en] solo para sí mismo: el hilo principal y los demás hilos no ven este cambio.

Un [ThreadLocal] requiere algunas precauciones. El valor de un hilo existe solo mientras exista el propio hilo: con un pool de hilos, el hilo que atiende una solicitud atenderá después otras, y [remove] debe llamarse al final de cada solicitud; de lo contrario, la siguiente solicitud encontraría los datos de la anterior (y la memoria nunca se liberaría). Con los hilos virtuales se pueden crear millones de hilos, cada uno con su propia copia de los datos: [InheritableThreadLocal] copia entonces sus valores en cada uno de ellos. Por último, un valor que puede ser modificado por cualquier método del hilo dificulta el seguimiento del código. La clase [ScopedValue] evita estos problemas.

8.12.3. La clase ScopedValue

Un valor [ScopedValue<T>] se enlaza a un valor durante la ejecución de un fragmento de código, llamado su ámbito:

  • [ScopedValue.newInstance()] crea un valor enlazable, normalmente almacenado en un campo [static final];
  • [ScopedValue.where(sv, value).run(action)] ejecuta la acción (un [Runnable]) enlazando [sv] a [value]. Durante la ejecución de la acción —y de todos los métodos que esta llama— en el hilo actual, [sv.get()] devuelve [value]. Cuando la acción termina, el enlace desaparece: no hay nada que limpiar;
  • [ScopedValue.where(sv, value).call(op)] hace lo mismo con una operación que devuelve un resultado;
  • Dentro del ámbito, el valor no puede modificarse; solo puede enlazarse a otro valor para un ámbito anidado;
  • [isBound()] indica si el valor está enlazado en el hilo actual; [orElse(other)] devuelve el valor o, si no está enlazado, [other]. Fuera de cualquier ámbito, [get()] lanza la excepción [NoSuchElementException].

El programa [Threads30.java] es el siguiente:

// valores ligados a un ámbito: ScopedValue (Java 25)

// el usuario por cuenta del cual se ejecuta el código
static final ScopedValue<String> USER = ScopedValue.newInstance();

void main() throws InterruptedException {
    IO.println("Outside of any scope, is USER bound? " + USER.isBound());
    try {
        USER.get();
    } catch (NoSuchElementException e) {
        IO.println("get() out of scope: " + e.getClass().getSimpleName());
    }

    // 1 - dos procesamientos simultáneos, cada uno para su usuario
    Thread t1 = Thread.ofVirtual().start(() -> ScopedValue.where(USER, "alice").run(this::process));
    Thread t2 = Thread.ofVirtual().start(() -> ScopedValue.where(USER, "bob").run(this::process));
    t1.join();
    t2.join();

    // 2 - un ámbito puede contener a otro, que liga temporalmente otro valor
    ScopedValue.where(USER, "admin").run(() -> {
        display("outer scope");
        ScopedValue.where(USER, "guest").run(() -> display("inner scope"));
        display("back in the outer scope");
        // un hilo creado en el ámbito no hereda el enlace
        Thread child = Thread.ofVirtual().start(
                () -> IO.println("child thread: bound? " + USER.isBound()));
        try {
            child.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });

    // 3 - call: un procesamiento ligado que devuelve un resultado
    String message = ScopedValue.where(USER, "carole").call(() -> "hello " + USER.get());
    IO.println(message);
    // tras el ámbito, el enlace ha desaparecido
    IO.println("After the scopes: bound? " + USER.isBound()
            + ", orElse: " + USER.orElse("nobody"));
}

// la capa [business] llama a la capa [dao] sin pasarle el usuario
void process() {
    display("[business] layer");
    dao();
}

// la capa [dao] encuentra el usuario en el ámbito actual
void dao() {
    display("[dao] layer");
}

// muestra el usuario ligado en el ámbito actual
static void display(String place) {
    IO.println(place + " : USER = " + USER.get());
}

Comentarios:

  • línea 4: el valor enlazado [USER], un campo estático de la clase implícita;
  • líneas 7–12: fuera de cualquier ámbito, el valor no está enlazado y [get] lanza una excepción;
  • líneas 15–16: dos hilos virtuales ejecutan el método [process], cada uno dentro de un ámbito en el que [USER] está enlazado a un usuario distinto;
  • líneas 44–52: el método [process] (la capa [business]) llama al método [dao] (la capa [dao]) sin pasarle el usuario: cada uno lo obtiene mediante [USER.get()] (línea 56);
  • líneas 21–33: un ámbito en el que [USER] es igual a [admin] contiene un ámbito anidado (línea 23) en el que es igual a [guest]. Al salir del ámbito anidado, volvemos a encontrar [admin];
  • líneas 26–27: un hilo creado dentro del ámbito no ve el enlace: a diferencia de un *[InheritableThreadLocal]*, un *[ScopedValue] no se transmite a los hilos creados mediante *[Thread]. Sí se transmite, en cambio, a las subtareas de la concurrencia estructurada ([StructuredTaskScope], en versión preliminar en Java 25), que garantiza que estas subtareas terminen antes de que finalice el ámbito;
  • línea 36: [call] ejecuta una operación dentro de un ámbito y devuelve su resultado;
  • líneas 39–40: después de los ámbitos, el valor ya no está enlazado.

Resultados:

> java Threads30.java
Outside of any scope, is USER bound? false
get() out of scope: NoSuchElementException
[business] layer : USER = alice
[dao] layer : USER = alice
[business] layer : USER = bob
[dao] layer : USER = bob
outer scope : USER = admin
inner scope : USER = guest
back in the outer scope : USER = admin
child thread: bound? false
hello carole
After the scopes: bound? false, orElse: nobody

Los mensajes de los hilos virtuales en las líneas 4–7 pueden aparecer en un orden distinto (bob antes que alice); el resto es reproducible. Un [ScopedValue] es adecuado para datos de contexto transmitidos «hacia abajo», desde el llamador hacia los métodos llamados: usuario autenticado, transacción, configuración regional, etc. Cuando un método llamado necesita modificar los datos para un procesamiento posterior, se requiere un [ThreadLocal].

8.12.4. Aplicación: una transacción compartida entre capas

Consideremos la siguiente aplicación de tres capas, en la que la capa [dao] gestiona una tabla de artículos:

Image

Supongamos que la interfaz de la capa [dao] es inicialmente la siguiente:

1
2
3
4
5
6
7
interface IDao {
    int insertArticle(Article article);

    List<Article> getAllArticles();

    void deleteAllArticles();
}

Más adelante surge la necesidad de insertar una lista de artículos dentro de una transacción, porque el sistema debe funcionar con el criterio de todo o nada: o se insertan todos los artículos, o no se inserta ninguno. Se puede agregar a la interfaz un método llamado [insertArticles(List<Article> articles)]. Después, para otra aplicación, surge la necesidad de eliminar una lista de artículos, de nuevo dentro de una transacción… Para satisfacer distintas necesidades de negocio, la capa [dao] irá creciendo. Podemos adoptar otro enfoque:

  • incluir en la capa [dao] únicamente las operaciones básicas (insertar, actualizar, eliminar y leer un artículo);
  • trasladar a la capa [business] las operaciones que actualizan varios artículos simultáneamente. Estas operaciones utilizan las operaciones básicas de la capa [dao].

La ventaja de esta solución es que la misma capa [dao] puede utilizarse sin modificaciones con diferentes capas [business]. Introduce, sin embargo, una dificultad en la gestión de la transacción que agrupa las actualizaciones que deben realizarse de forma atómica:

  • la transacción debe ser iniciada por la capa [business] antes de que esta llame a los métodos de la capa [dao];
  • los métodos de la capa [dao] deben conocer la existencia de la transacción para poder participar en ella;
  • la transacción debe ser finalizada (confirmada o cancelada) por la capa [business].

Para que los métodos de la capa [dao] conozcan cualquier transacción en curso, se podría agregar la transacción como parámetro a cada método de la capa [dao]. Este parámetro aparecería entonces en la firma de los métodos de la interfaz, vinculando así la interfaz a una fuente de datos específica. Los datos locales al hilo ofrecen una solución más elegante: la capa [business] coloca la transacción en los datos locales al hilo, y de ahí la recupera la capa [dao]. Las firmas de los métodos de la capa [dao] no necesitan modificarse. Varios hilos (varios usuarios) pueden trabajar simultáneamente: cada uno tiene su propia transacción.

Las bases de datos se tratarán en los capítulos 10 y 11. Para mantener el foco en los hilos, aquí utilizamos una tabla en memoria y una transacción simulada. El programa [Threads31.java] reúne todas las capas en un único archivo fuente compacto. Las entidades son las siguientes:

// un artículo
record Article(int id, String name, double price, int currentStock, int minimumStock) {
}

// una transacción simulada: registra cómo deshacer cada actualización
static class Transaction {
    private static final AtomicInteger counter = new AtomicInteger();
    private final Deque<Runnable> undos = new ArrayDeque<>();
    private final int number = counter.incrementAndGet();

    int getNumber() {
        return number;
    }

    // registra la operación que deshace una actualización
    void log(Runnable undo) {
        undos.push(undo);
    }

    // confirma la transacción: las actualizaciones se conservan
    void commit() {
        undos.clear();
    }

    // revierte la transacción: las actualizaciones se deshacen, de la última a la primera
    void rollback() {
        Runnable undo;
        while ((undo = undos.poll()) != null) {
            undo.run();
        }
    }
}

// los datos locales al hilo compartidos por las capas
static class ThreadContext {
    // la transacción actual del hilo (null si no hay ninguna)
    static final ThreadLocal<Transaction> transaction = new ThreadLocal<>();
}
  • línea 68: un artículo es un [record] cuyo identificador [id] lo establece la capa [dao];
  • líneas 72–98: una transacción simulada. Cada actualización realizada dentro de la transacción registra la operación que permite revertirla (método [log]); [commit] confirma la transacción ignorando esas operaciones; [rollback] la revierte ejecutando las operaciones de reversión, de la última a la primera. Las operaciones se almacenan en una pila: el método [push] de un [Deque] agrega en la parte superior, mientras que el método [poll] extrae de la parte superior (y devuelve [null] si la pila está vacía). Una base de datos real funciona de manera similar, mediante un registro de transacciones;
  • línea 75: a cada transacción se le asigna un número único. Como varios hilos pueden crear transacciones simultáneamente, el contador es un [AtomicInteger], que se incrementa de forma atómica;
  • líneas 101–104: los datos locales al hilo compartidos por las capas: la transacción actual del hilo, o [null] si no hay ninguna.

La capa [dao] es la siguiente:

// la capa [dao]: una tabla de artículos en memoria con una restricción de unicidad sobre el nombre
interface IDao {
    int insertArticle(Article article);

    List<Article> getAllArticles();

    void deleteAllArticles();
}

static class Dao implements IDao {
    // la tabla, compartida por todos los hilos, y su bloqueo
    private final List<Article> table = new ArrayList<>();
    private final Object lock = new Object();
    private int nextId = 1;

    @Override
    public int insertArticle(Article article) {
        // ¿hay una transacción en curso en el hilo actual?
        Transaction transaction = ThreadContext.transaction.get();
        synchronized (lock) {
            if (table.stream().anyMatch(a -> a.name().equals(article.name()))) {
                throw new IllegalStateException("an article named [" + article.name() + "] already exists");
            }
            Article inserted = new Article(nextId++, article.name(), article.price(),
                    article.currentStock(), article.minimumStock());
            table.add(inserted);
            // en una transacción, se registra cómo deshacer la inserción
            if (transaction != null) {
                transaction.log(() -> {
                    synchronized (lock) {
                        table.remove(inserted);
                    }
                });
            }
            String mode = transaction == null
                    ? "outside a transaction"
                    : "in transaction " + transaction.getNumber();
            IO.println("[" + Thread.currentThread().getName() + "] [dao] insertion of " + inserted.name()
                    + " (id " + inserted.id() + ") " + mode);
            return 1;
        }
    }

    @Override
    public List<Article> getAllArticles() {
        synchronized (lock) {
            return List.copyOf(table);
        }
    }

    @Override
    public void deleteAllArticles() {
        synchronized (lock) {
            table.clear();
        }
    }
}
  • línea 117: la tabla de artículos, compartida por todos los hilos. El acceso a ella está protegido por el bloqueo de la línea 118;
  • línea 124: el método [insertArticle] recupera la transacción que la capa [business] haya colocado en los datos locales del hilo actual;
  • líneas 126–128: la tabla tiene una restricción de unicidad sobre los nombres de los artículos: insertar un artículo con un nombre que ya existe lanza una excepción;
  • líneas 129–131: el artículo insertado es una copia del artículo recibido, con un identificador asignado por la capa [dao]. Como un objeto [record] es de solo lectura, se crea un objeto nuevo;
  • líneas 133–139: si hay una transacción, la capa [dao] participa registrando cómo revertir la inserción. La lambda de reversión captura la variable [inserted];
  • líneas 140–144: una salida de traza muestra el hilo, el artículo insertado y la transacción, si la hay;
  • líneas 150–154: la lista de artículos devuelta es una copia de solo lectura de la tabla ([List.copyOf]), para que el llamador no la recorra mientras otro hilo la modifica.

La capa [business] es la siguiente:

// la capa [business]
interface IBusiness {
    void insertArticlesInTransaction(List<Article> articles);

    void insertArticlesOutOfTransaction(List<Article> articles);

    List<Article> getAllArticles();

    void deleteAllArticles();
}

static class Business implements IBusiness {
    private final IDao dao;

    Business(IDao dao) {
        this.dao = dao;
    }

    // inserción de una lista de artículos: todo o nada
    @Override
    public void insertArticlesInTransaction(List<Article> articles) {
        // inicio de la transacción, almacenada en los datos locales al hilo
        var transaction = new Transaction();
        ThreadContext.transaction.set(transaction);
        try {
            for (Article article : articles) {
                // la capa [dao] encontrará la transacción en el hilo
                dao.insertArticle(article);
                // procesamiento simulado, que da tiempo a otros hilos para intervenir
                sleep(200);
            }
            transaction.commit();
            IO.println("[" + Thread.currentThread().getName() + "] [business] transaction "
                    + transaction.getNumber() + " committed");
        } catch (RuntimeException e) {
            transaction.rollback();
            IO.println("[" + Thread.currentThread().getName() + "] [business] transaction "
                    + transaction.getNumber() + " rolled back");
            // la excepción se vuelve a lanzar al llamador
            throw e;
        } finally {
            // el hilo ya no tiene una transacción en curso
            ThreadContext.transaction.remove();
        }
    }

    // inserción de una lista de artículos sin transacción
    @Override
    public void insertArticlesOutOfTransaction(List<Article> articles) {
        for (Article article : articles) {
            dao.insertArticle(article);
        }
    }

    @Override
    public List<Article> getAllArticles() {
        return dao.getAllArticles();
    }

    @Override
    public void deleteAllArticles() {
        dao.deleteAllArticles();
    }
}
  • líneas 176–180: la capa [dao] se inyecta mediante el constructor;
  • líneas 186–187: el método [insertArticlesInTransaction] inicia una transacción y la guarda en los datos locales del hilo;
  • línea 191: se llama al método de inserción de la capa [dao] para cada artículo, sin pasarle la transacción;
  • línea 193: una pausa simula un procesamiento, con el fin de dar tiempo a que otro hilo intervenga durante la transacción (tercera parte del programa de prueba);
  • línea 195: si el programa llega a este punto, no se ha producido ninguna excepción: la transacción se confirma;
  • líneas 198–203: si se produce una excepción, la transacción se revierte y la excepción se vuelve a lanzar al llamador;
  • línea 206: en todos los casos, el hilo ya no tiene una transacción activa: [remove()] elimina el identificador de la transacción del hilo. Esto es esencial si el hilo se reutiliza (un hilo de un pool);
  • Líneas 212–216: la misma inserción, sin transacción.

El programa de prueba es el siguiente:

// datos locales al hilo: la capa [business] coloca allí la transacción, la capa [dao] la encuentra allí

void main() throws InterruptedException {
    // las capas de la aplicación
    IDao dao = new Dao();
    IBusiness business = new Business(dao);
    Thread.currentThread().setName("Main");

    // dos artículos con el mismo nombre: el segundo viola la restricción de unicidad sobre el nombre
    List<Article> articles = List.of(new Article(0, "article", 100, 10, 1),
            new Article(0, "article", 100, 10, 1));

    // 1 - inserción fuera de una transacción
    IO.println("Inserting the articles outside a transaction...");
    execute(() -> business.insertArticlesOutOfTransaction(articles));
    displayArticles(business);

    // 2 - inserción en una transacción
    business.deleteAllArticles();
    IO.println("Inserting the articles in a transaction...");
    execute(() -> business.insertArticlesInTransaction(articles));
    displayArticles(business);

    // 3 - dos hilos simultáneos: la transacción del hilo A no es vista por el hilo B
    business.deleteAllArticles();
    IO.println("Two simultaneous threads...");
    List<Article> articlesA = List.of(new Article(0, "keyboard", 20, 5, 1), new Article(0, "mouse", 10, 5, 1),
            new Article(0, "keyboard", 20, 5, 1));
    List<Article> articlesB = List.of(new Article(0, "screen", 150, 2, 1));
    var threadA = new Thread(() -> execute(() -> business.insertArticlesInTransaction(articlesA)), "A");
    var threadB = new Thread(() -> execute(() -> business.insertArticlesOutOfTransaction(articlesB)), "B");
    threadA.start();
    Thread.sleep(100);
    threadB.start();
    threadA.join();
    threadB.join();
    displayArticles(business);
}

// ejecuta una acción, mostrando la posible excepción
static void execute(Runnable action) {
    try {
        action.run();
    } catch (RuntimeException e) {
        IO.println("[" + Thread.currentThread().getName() + "] " + e.getClass().getSimpleName()
                + " : " + e.getMessage());
    }
}

// espera de [ms] milisegundos
static void sleep(long ms) {
    try {
        Thread.sleep(ms);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// muestra la lista de artículos
static void displayArticles(IBusiness business) {
    IO.println("List of articles:");
    for (Article article : business.getAllArticles()) {
        IO.println("  " + article);
    }
}
  • Línea 10: creamos una lista de dos artículos con el mismo nombre. El intento de insertar el segundo artículo será rechazado. Si la inserción se realiza fuera de una transacción, el primer artículo se inserta y permanece en la lista. Si se realiza dentro de una transacción, el primer artículo se inserta y luego se elimina cuando la transacción se revierte;
  • Líneas 13–16: se inserta la lista fuera de una transacción y luego se muestra la tabla;
  • Líneas 18–22: el mismo procedimiento dentro de una transacción;
  • líneas 24–37: dos hilos trabajan simultáneamente. El hilo A inserta tres artículos dentro de una transacción (el tercero viola la restricción de unicidad); mientras tanto, el hilo B inserta un artículo fuera de una transacción;
  • líneas 41–48: el método [execute] ejecuta una acción y muestra cualquier excepción, precedida por el nombre del hilo.

Resultados:

> java Threads31.java
Inserting the articles outside a transaction...
[Main] [dao] insertion of article (id 1) outside a transaction
[Main] IllegalStateException : an article named [article] already exists
List of articles:
  Article[id=1, name=article, price=100.0, currentStock=10, minimumStock=1]
Inserting the articles in a transaction...
[Main] [dao] insertion of article (id 2) in transaction 1
[Main] [business] transaction 1 rolled back
[Main] IllegalStateException : an article named [article] already exists
List of articles:
Two simultaneous threads...
[A] [dao] insertion of keyboard (id 3) in transaction 2
[B] [dao] insertion of screen (id 4) outside a transaction
[A] [dao] insertion of mouse (id 5) in transaction 2
[A] [business] transaction 2 rolled back
[A] IllegalStateException : an article named [keyboard] already exists
List of articles:
  Article[id=4, name=screen, price=150.0, currentStock=2, minimumStock=1]
  • La inserción fuera de la transacción dejó el primer registro en la tabla (línea 6). El método [toString] de un [record] muestra el nombre y el valor de cada uno de sus componentes;
  • La inserción realizada dentro de una transacción no dejó ningún registro en la tabla: el registro con ID 2 fue eliminado por la reversión;
  • En la tercera parte, el hilo B insertó la pantalla mientras la transacción 2 del hilo A estaba en curso: lo hizo fuera de la transacción, ya que la transacción es una variable local del hilo A. La reversión de la transacción 2 eliminó el teclado y el mouse insertados por A, pero no la pantalla insertada por B. Este resultado es reproducible.

8.12.5. Conclusión

El ejemplo anterior demostró el valor de los datos locales al hilo para la gestión de transacciones. No debe replicarse exactamente tal como se muestra, pero describe con precisión cómo funcionan los frameworks: la gestión de transacciones de Spring (anotación [@Transactional]) coloca la transacción y la conexión a la base de datos en un [ThreadLocal], que las capas de acceso a datos consultan sin que su código tenga que manipular la transacción; Hibernate puede, de forma similar, asociar la sesión de trabajo con el hilo actual. Volveremos sobre estas herramientas en el capítulo 11. En código nuevo, en particular al usar hilos virtuales, un *[ScopedValue]* es la forma recomendada de transmitir este tipo de información contextual.

8.13. Lecturas adicionales

La sincronización de hilos es un campo difícil. Este capítulo ha presentado las principales herramientas; para profundizar:

  • el libro de Brian Goetz y otros, [Java Concurrency in Practice] (Addison-Wesley), que sigue siendo la referencia definitiva sobre el tema, aunque es anterior a los hilos virtuales;
  • la sección «Concurrency» del tutorial de Java de Oracle: Lesson: Concurrency, que está desactualizada pero sigue siendo correcta en lo básico;
  • la documentación del paquete [java.util.concurrent]: Package java.util.concurrent, cuya sección «Memory Consistency Properties» resume las relaciones «happens-before»;
  • las propuestas de mejora de Java (JEP) que introdujeron los hilos virtuales y los valores con ámbito: JEP 444: Virtual Threads y JEP 506: Scoped Values.

En el código moderno, rara vez se manipulan directamente los objetos [Thread]. En su lugar, se prefieren los executors ([ExecutorService]), los streams paralelos para los cálculos y los hilos virtuales para los procesos de espera. El capítulo siguiente presenta la programación asíncrona mediante la clase [CompletableFuture], que permite encadenar procesos a la finalización de una operación larga (acceso a la red, a una base de datos o a un archivo) sin bloquear un hilo. Sin embargo, los conceptos tratados en este capítulo siguen siendo esenciales: todas estas tareas se ejecutan en hilos, y los datos que comparten deben protegerse con las mismas herramientas ([synchronized], bloqueos, clases atómicas, colecciones concurrentes).