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:
Resultados:
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:
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:
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:
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:
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.
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:
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:
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:
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:
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:
- 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:

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:

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:
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:
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:
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):
Con 5 hilos:
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:
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:
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:
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]:
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:
- 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]:
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:
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:
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:
Resultados del proceso B:
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]):
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:
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:
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:
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:
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:
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.
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:
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:
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:
- 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]:
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:
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:
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:
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]):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | |
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:
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:
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:
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:
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:
- 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:
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:
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:
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:
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:
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:
- 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:
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:
- 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:
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:
- 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:
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:
- 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:

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]:
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:
- 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:
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:
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:

Supongamos que la interfaz de la capa [dao] es inicialmente la siguiente:
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:
- 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:
- 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:
- 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:
- 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:
- 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).