Iniciar prueba gratuita
Popular Nuevos Géneros Autores
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Buscando...
SoBrief
Java Concurrency in Practice

Java Concurrency in Practice

Desarrolla servicios Java que sigan siendo correctos bajo carga, sin convertir cada valor compartido en un bloqueo.
por Brian Goetz 2005 432 páginas
4.48
2000+ valoraciones
Escuchar
Inmersivo
V2.3
Amazon Kindle Audible
Prueba el acceso completo por 3 días
¡Desbloquea la escucha y mucho más!
Continuar

Ideas clave

Aborda la concurrencia como un problema de estado mutable compartido, no de cantidad de hilos

Sigue los datos. Los hilos son útiles para atender solicitudes independientes, mantener una interfaz de usuario receptiva y aprovechar varios procesadores. Pero lo difícil no es iniciar hilos, sino coordinar el acceso a datos que varios hilos pueden modificar. Una clase es segura para los hilos cuando sigue cumpliendo su especificación sin importar cómo se intercalen sus operaciones, sin que quienes la usan tengan que añadir su propia sincronización.

Identifica a todos los propietarios. Un servlet puede parecer secuencial dentro de su propio método y, aun así, un framework puede invocarlo desde varios hilos a la vez. Incluso las aplicaciones que nunca crean hilos directamente pueden recibirlos a través de herramientas de interfaz gráfica, temporizadores o frameworks de servidor. Por tanto, la pregunta práctica inicial no es «¿Dónde están los hilos?», sino «¿A qué estado mutable pueden acceder?»

Análisis

Enfocarse primero en el estado transforma un tema intimidante en una auditoría manejable: identificar qué se comparte, qué puede cambiar y quién puede acceder a ello. Esto se parece al modelado de amenazas en seguridad, donde la atención se centra en los recursos expuestos y las vías de acceso, no en si un sistema parece complicado. Los ejemplos de frameworks son importantes porque muestran que la concurrencia suele ser una propiedad heredada del entorno de un componente. Una limitación es que los límites del estado pueden ser difíciles de percibir cuando las referencias circulan por callbacks o contenedores, por lo que la encapsulación y la documentación son partes esenciales del diseño técnico.

Protege invariantes completas, no solo lecturas y escrituras individuales

Mantén válidos los estados. Incrementar un contador parece una sola acción, pero implica leer el valor anterior, sumarle uno y escribir el resultado. Dos hilos pueden leer el mismo valor y perder una actualización. Esto es una condición de carrera: la corrección depende de que el momento sea propicio. Una secuencia de comprobación y acción, como verificar si una caché está vacía antes de llenarla, presenta la misma vulnerabilidad.

Mantén junto el estado relacionado. Dos campos que son atómicos por separado aún pueden infringir una regla compartida. Un dato de entrada almacenado en caché y su resultado deben corresponder al mismo cálculo, así que actualizarlos o leerlos por separado puede dejar al descubierto un par que no coincide. Protege las variables relacionadas con el mismo bloqueo y mantén cada operación compuesta dentro de una única sección protegida. Si hay que esperar a que se cumpla una condición de estado, compruébala mientras se mantiene el bloqueo correspondiente; luego espera en un bucle y vuelve a comprobarla al despertar.

Análisis

Una invariante es una formulación concisa de lo que debe seguir siendo cierto y proporciona una unidad de análisis útil para el diseño concurrente. El cambio fundamental consiste en dejar de preguntarse si cada campo está protegido y preguntarse si cada transición permitida preserva las reglas del objeto. Esto se asemeja al diseño de transacciones: una secuencia que debe comportarse como un cambio indivisible necesita un límite atómico. Hay que tener en cuenta, sin embargo, que los bloqueos demasiado amplios pueden preservar la corrección serializando mucho más trabajo del necesario. Primero, la invariante define el límite adecuado; después, se puede refinar con cuidado para mejorar el rendimiento.

Elige el confinamiento o la inmutabilidad antes de recurrir a otro bloqueo

Haz innecesario compartir. Si un objeto solo lo usa un hilo, no necesita sincronización, aunque sea mutable. Las variables locales quedan confinadas de manera natural a la pila de su hilo, siempre que sus referencias no escapen. Swing adopta un enfoque similar a mayor escala: los componentes y modelos de la interfaz gráfica solo son accesibles desde el hilo de despacho de eventos, mientras que el trabajo prolongado se ejecuta en otro lugar.

Inmoviliza lo que puedas. Un objeto inmutable no puede cambiar después de construirse, así que sus invariantes no necesitan protección frente a actualizaciones concurrentes. Un sistema de seguimiento de vehículos puede almacenar objetos de coordenadas inmutables y reemplazarlos cuando cambian las ubicaciones. ThreadLocal proporciona un valor independiente a cada hilo, pero puede ocultar dependencias y desperdiciar recursos compartidos si se usa sin cuidado. El confinamiento y la inmutabilidad reducen la cantidad de estados sobre los que debe razonar quien programa.

Análisis

Esta es una estrategia de diseño, no un mero truco de programación: elimina las condiciones que hacen necesaria la coordinación. La inmutabilidad traslada la complejidad al reemplazo y la asignación de objetos, mientras que el confinamiento la traslada a las reglas de propiedad. Ambos enfoques pueden ser más fáciles de entender que un protocolo de bloqueos entretejido en muchos métodos. El ejemplo de Swing también ilustra un límite útil entre una interfaz receptiva y el cálculo en segundo plano. ThreadLocal, sin embargo, exige prudencia. El estado por hilo puede convertir discretamente un único recurso compartido en muchas copias privadas, lo que cambia tanto la semántica del programa como su consumo de memoria.

Publica objetos mediante una transferencia segura para la memoria, no solo haciendo visible una referencia

La visibilidad forma parte de la seguridad. La sincronización no solo impide que dos hilos entren a la vez en una sección crítica. También establece cuándo las escrituras de un hilo pasan a ser visibles para otro. Sin ese orden, un lector puede ver un indicador antiguo, no llegar a ver una escritura o encontrarse con una referencia a un objeto antes de que sus campos parezcan estar completamente inicializados.

Usa mecanismos de transferencia definidos. La publicación segura puede realizarse mediante un inicializador estático, un campo volatile, un campo protegido correctamente o una colección o cola segura para los hilos. Los objetos inmutables con campos final reciben garantías adicionales de inicialización si se construyen correctamente. Un indicador volatile puede anunciar un cambio en el ciclo de vida, pero no puede hacer atómico un incremento compuesto por varios pasos. El Modelo de memoria de Java describe estas garantías mediante relaciones ocurre-antes (happens-before), que conectan determinadas escrituras y lecturas entre hilos.

Análisis

La diferencia entre hacer visible una referencia y hacer visible el estado del objeto al que apunta es una de las advertencias más importantes del libro. Explica por qué un programa puede parecer correcto en las pruebas habituales y, aun así, fallar con otro compilador o una planificación distinta del procesador. La idea de una transferencia segura es más fácil de aplicar que razonar sobre cada operación de memoria y concuerda con los patrones de transferencia de propiedad de los sistemas concurrentes. Aun así, volatile no es un atajo de uso general: su sencillez resulta útil precisamente cuando la transición de estado es lo bastante simple como para verificarla.

Delega la coordinación rutinaria en componentes concurrentes probados

Combina, no improvises. Los componentes seguros para los hilos pueden asumir por sí mismos parte de la responsabilidad de mantener la seguridad. ConcurrentHashMap permite el acceso concurrente sin serializar todas las operaciones detrás de un único bloqueo para todo el mapa. BlockingQueue coordina productores y consumidores, mientras que los semáforos, las compuertas y las barreras controlan el acceso o la sincronización temporal entre hilos. Estos componentes básicos implementan protocolos que es fácil manejar mal con bloqueos elementales y esperas en condiciones.

Comprueba la composición. Una caché que guarda valores ya calculados en un mapa concurrente aún puede calcular dos veces el mismo valor ausente. Si se almacena un FutureTask por cada entrada, las llamadas posteriores pueden esperar a que termine el cálculo existente. Una operación atómica de «insertar si no existe» cierra la condición de carrera en la que dos hilos empiezan el trabajo a la vez. Delegar solo funciona cuando los componentes son independientes o cuando la operación compuesta completa se gestiona de forma atómica.

Análisis

El enfoque del libro, centrado en las bibliotecas, refleja un principio de ingeniería más amplio: las abstracciones reutilizables pueden incorporar años de pruebas y diseño, a la vez que reducen la cantidad de protocolos propios que cada aplicación debe mantener. El ejemplo de la caché resulta especialmente instructivo porque distingue entre proteger una estructura de datos y coordinar el trabajo que esa estructura representa. Sin embargo, un componente seguro no hace que toda composición de mayor escala sea segura automáticamente. La integración sigue necesitando una descripción explícita de las invariantes compartidas, la semántica de los valores devueltos y el comportamiento ante fallos.

Convierte el trabajo en tareas limitadas y haz que alguien asuma explícitamente la sobrecarga

Separa el trabajo de quienes lo ejecutan. Un Executor desacopla el envío de tareas de la política que determina cómo se ejecutan. Crear un hilo nuevo por cada solicitud puede mejorar la capacidad de respuesta al principio, pero la creación ilimitada de hilos consume memoria y puede derribar un servicio. Un conjunto de hilos reutiliza trabajadores y controla cuántas tareas se ejecutan a la vez; su cola y su política de rechazo determinan qué sucede cuando la demanda supera la capacidad.

Deja que las colas regulen el flujo. En un patrón productor-consumidor, los productores colocan el trabajo en una cola y los consumidores lo recogen cuando pueden. Una cola limitada crea contrapresión: cuando se llena, los productores esperan o el sistema aplica la política de sobrecarga elegida. Las tareas independientes son las más fáciles de planificar con flexibilidad. Las tareas dependientes pueden provocar un interbloqueo si los trabajadores del conjunto esperan tareas que siguen encoladas, así que la política de ejecución debe ser adecuada para las tareas.

Análisis

La idea clave es que gestionar la capacidad forma parte de la corrección y la calidad del servicio; no es un mero detalle de ajuste. Una cola no elimina la sobrecarga: determina dónde se acumula y quién la experimenta. Las colas limitadas hacen visible esa decisión, mientras que las políticas de ejecutar en el hilo llamante y de rechazo la llevan a la práctica. Esto guarda una estrecha relación con el control de flujo en los sistemas de comunicación, donde el emisor debe ralentizarse o hay que descartar el trabajo sobrante. Un conjunto de hilos puede seguir fallando si su cola no tiene límite; por tanto, limitar solo el número de trabajadores no constituye una política completa de recursos.

Diseña la cancelación y el cierre como parte del contrato del servicio

Detente de forma cooperativa. Java no puede detener de manera segura un hilo en ejecución a mitad de un trabajo arbitrario. La interrupción es una solicitud que una tarea puede atender cuando llega a un punto adecuado para detenerse, a menudo abandonando antes una operación bloqueante. El código de una tarea debe propagar InterruptedException o restaurar el estado de interrupción si no puede propagar la excepción. Ignorar una interrupción en silencio puede impedir que el servicio responsable se cierre correctamente.

Define cómo termina. Un servicio debe especificar si, durante el cierre, deja de aceptar trabajo nuevo, termina las tareas encoladas, cancela las tareas en ejecución o conserva el trabajo pendiente para reanudarlo después de reiniciarse. ExecutorService ofrece opciones de cierre ordenado y abrupto. Por ejemplo, un servicio de registro debe tener en cuenta los mensajes que siguen encolados y los productores bloqueados mientras los envían. Los fallos de tareas que no se capturan también necesitan una vía de gestión visible, como el registro de errores o un manejador de excepciones.

Análisis

El comportamiento durante el ciclo de vida es el punto en que el diseño concurrente se encuentra con las expectativas de los usuarios. Un botón para cancelar, una solicitud para detener un servidor y la salida de un proceso piden cambiar el curso futuro de una actividad, pero no necesariamente implican el mismo tipo de limpieza o las mismas garantías sobre los datos. La interrupción cooperativa permite que una tarea preserve sus propias invariantes mientras responde a quien la controla. El coste es que no se puede dar por sentada la rapidez de respuesta: puede que el código bloqueado en ciertas operaciones de E/S necesite un mecanismo de cancelación aparte, como cerrar el recurso subyacente. Los contratos claros del servicio explicitan estas diferencias.

Evita los interbloqueos con un orden global de bloqueos y llamadas fuera de ellos

Rompe las esperas circulares. Hay interbloqueo cuando los hilos forman un ciclo de dependencias y cada uno retiene un recurso que necesita otro. Si un método bloquea primero la cuenta A y luego la B, mientras que otro bloquea primero la B y luego la A, ambos pueden quedar esperando para siempre. Exigir que todos los hilos adquieran los bloqueos siguiendo un mismo orden global coherente impide esta forma de interbloqueo, incluso cuando el orden debe determinarse a partir de los identificadores de cuenta.

Mantén abiertas las llamadas. Es peligroso llamar, mientras se mantiene un bloqueo, a código que está fuera del control de una clase: ese código puede adquirir otro bloqueo o bloquearse de forma inesperada. Una llamada abierta es una llamada a un método que se realiza sin mantener ningún bloqueo. Reducir la sección protegida antes de llamar a código externo disminuye tanto el riesgo de interbloqueo como la contención. Los conjuntos de hilos también pueden sufrir interbloqueo cuando todos los trabajadores esperan tareas dependientes encoladas en ese mismo conjunto.

Análisis

El problema de los filósofos que cenan da al interbloqueo una forma intuitiva: cada participante tiene parte de lo que otro necesita y nadie suelta lo que tiene. En el software, el ciclo puede atravesar los límites entre objetos o incluso la capacidad del conjunto de hilos, por lo que revisar un método aislado puede no bastar para detectarlo. El orden global es eficaz porque descarta estructuralmente la posibilidad de ciclos. Las llamadas abiertas lo complementan al reducir las dependencias ocultas. Estas técnicas exigen coordinación entre componentes, por lo que las políticas de sincronización y las restricciones de ejecución deben documentarse, en lugar de dejarse como conocimiento tácito.

Optimiza los cuellos de botella medidos; la serialización fija el límite de velocidad

Identifica el recurso limitante. Los hilos añaden costes de planificación, coordinación y sincronización de memoria, así que el código paralelo no es automáticamente más rápido. La ley de Amdahl muestra por qué: si el 10 % de un cálculo debe seguir siendo secuencial, ni siquiera un número ilimitado de procesadores puede lograr una aceleración superior a diez veces. Las colas compartidas, el registro de eventos y los contadores globales pueden convertirse en pasos serializados ocultos.

Reduce la contención de forma selectiva. Evita mantener los bloqueos durante cálculos prolongados y operaciones de E/S bloqueantes. Divide los bloqueos que protegen estados independientes o usa fragmentación para distribuir el acceso entre distintas partes de una colección. Las colecciones concurrentes, los bloqueos de lectura y escritura y las variables atómicas pueden ayudar cuando su semántica es adecuada. Compara el rendimiento con cargas realistas: una contención elevada puede hacer que las actualizaciones atómicas con espera activa resulten menos atractivas que los bloqueos bloqueantes, y es posible que los resultados de una prueba comparativa obtenidos en una JVM o máquina no se reproduzcan en otra.

Análisis

La ley de Amdahl es útil no porque prediga el resultado de todas las pruebas, sino porque obliga a prestar atención a las partes de un diseño que inevitablemente deben ser secuenciales. Los consejos de rendimiento que la acompañan evitan una trampa habitual: optimizar la operación visible e ignorar la coordinación compartida que la rodea. Esta perspectiva también explica por qué una implementación que realiza más asignaciones puede escalar mejor si reduce la contención. La contrapartida es la complejidad. Los bloqueos más granulares y los algoritmos no bloqueantes pueden aumentar el rendimiento, pero los riesgos para su mantenimiento y progreso son costes reales, no notas al margen.

Prueba los entrelazamientos, el rendimiento y las suposiciones con defensas independientes

Pon a prueba la planificación. Los fallos concurrentes pueden depender de momentos poco habituales, así que superar una prueba unitaria no demuestra que el código sea seguro. Las pruebas pueden ejecutar muchos productores y consumidores, sincronizar su inicio mediante una barrera y comparar sumas de comprobación para detectar elementos perdidos o duplicados, sin añadir una estructura de auditoría muy disputada. Siempre que sea posible, las pruebas deben incluir más hilos activos que procesadores y ejecutarse en sistemas distintos.

No confíes en una sola prueba. Las mediciones de rendimiento pueden distorsionarse por la recolección de basura, la compilación dinámica, una contención poco realista o trabajo que el compilador elimina por considerarlo código muerto. Combina las pruebas de esfuerzo y rendimiento con revisiones de código y análisis estático. Al diagnosticar interbloqueos o contención, examina los volcados de hilos. Estos métodos detectan tipos de errores distintos y cada uno aporta pruebas, no una garantía matemática de que se hayan encontrado todos los fallos.

Análisis

Probar código concurrente es, en sí mismo, un problema de concurrencia: la instrumentación puede añadir sincronización, alterar los tiempos u ocultar el defecto que se intenta investigar. Las sumas de comprobación y los inicios coordinados son ingeniosos porque aumentan los entrelazamientos útiles y, a la vez, limitan la interferencia con la carga de trabajo. La lección general es epistemológica: la confianza surge de combinar métodos con modos de fallo diferentes, no de considerar concluyente una única prueba prolongada. Una revisión de código puede identificar una transición de estado prohibida antes de que ocurra; las pruebas de esfuerzo pueden revelar comportamientos difíciles de prever con solo inspeccionar el código.

Análisis

Java Concurrency in Practice se entiende mejor como un manual de diseño para controlar el estado compartido que como un catálogo de API de hilos. Su argumento pasa del problema local de las actualizaciones atómicas a la arquitectura más amplia de la ejecución de tareas, los límites de recursos, el cierre y el rendimiento. Esa progresión es importante: un método sincronizado correcto aún puede dar lugar a un servicio lento, mientras que un ejecutor escalable puede albergar tareas que sufren condiciones de carrera, interbloqueos o nunca terminan.

La mayor aportación del libro es su insistencia constante en hacer explícitas las políticas de concurrencia. ¿Qué bloqueos protegen qué campos? ¿Qué tareas pueden depender unas de otras? ¿Quién es responsable de un hilo trabajador y qué significa para este una interrupción? Estas preguntas convierten una cautela vaga en restricciones de diseño que pueden revisarse. La encapsulación, la inmutabilidad y la publicación segura no se presentan como preferencias estéticas, sino como formas de reducir el sistema sobre el que hay que razonar.

Su tensión más útil es la que existe entre seguridad y rendimiento. Los bloqueos amplios son fáciles de entender, pero pueden serializar trabajo que no guarda relación entre sí. Los bloqueos granulares, las actualizaciones atómicas y los algoritmos no bloqueantes pueden mejorar la escalabilidad, pero su mayor complejidad genera nuevas obligaciones de demostración. Por eso, el libro considera la medición un requisito previo: optimiza un cuello de botella demostrado y evalúa el resultado con cargas de trabajo representativas, no basándote en la intuición ni en una prueba comparativa demasiado limitada.

Las API de Java 5 y 6 y las observaciones sobre rendimiento están ancladas en su época, así que quienes desarrollan hoy no deberían copiar todas las recomendaciones de ajuste sin comprobar el comportamiento actual de la plataforma. Las ideas perdurables son más estables que cualquier detalle concreto de implementación: preservar invariantes, aclarar la propiedad y las transferencias, limitar el uso de recursos, diseñar cómo terminar y probar mediante distintas formas de evidencia. La concurrencia se vuelve manejable no cuando se simula mentalmente cada entrelazamiento, sino cuando el diseño descarta categorías enteras de entrelazamientos peligrosos.

Resumen en 30 segundos
La corrección concurrente depende de proteger el estado relacionado como una unidad y de hacer visibles los cambios mediante transferencias seguras. Reduce la coordinación confinando los objetos mutables o haciéndolos inmutables, y usa colecciones concurrentes y utilidades de tareas consolidadas para el trabajo habitual. Limita los trabajadores y las tareas en cola para que la sobrecarga tenga una respuesta definida. Planifica la interrupción, el cierre y la prevención de interbloqueos. El paralelismo tiene límites: una parte serial del 10 % limita la aceleración a diez veces; por eso, mide cargas de trabajo realistas y combina pruebas de estrés con revisión de código y análisis.
Contiene spoilers

Última actualización:

Reportar problema

Resumen de reseñas

4.48 de 5
Promedio de 2000+ valoraciones de Goodreads y Amazon.

Java Concurrency in Practice recibe grandes elogios como lectura imprescindible para quienes desarrollan en Java. Los reseñistas valoran su cobertura exhaustiva de los conceptos de concurrencia, desde los temas básicos hasta los avanzados. El libro destaca por sus explicaciones claras, ejemplos prácticos y desarrollo gradual de los conocimientos. Muchos lectores aprecian sus ideas sobre el modelo de memoria de Java y las API relacionadas con la concurrencia. Aunque algunos señalan que está algo desactualizado, sus principios fundamentales siguen siendo pertinentes. Los lectores subrayan su valor para comprender e implementar código concurrente seguro y eficiente, y muchos lo consideran una lectura obligatoria para quienes programan en Java.

Tu valoración:
4.66
337 valoraciones
¿Quieres leer el libro completo?

También leyeron

Glosario

Modelo de memoria de Java

Reglas para la visibilidad entre hilos

El Modelo de memoria de Java especifica cuándo se garantiza que las acciones de memoria de un hilo sean visibles para otro. Define reglas de ordenación para eventos como la liberación y adquisición de bloqueos, las escrituras y lecturas de campos volatile, y el inicio y la finalización de hilos. La sincronización correcta establece las relaciones necesarias; sin ellas, las lecturas pueden obtener valores obsoletos o las operaciones pueden parecer reordenadas.

relación ocurre-antes (happens-before)

Una garantía de visibilidad y ordenación

La relación ocurre-antes (happens-before) es la relación de ordenación entre acciones que define el Modelo de memoria de Java. Si la acción A ocurre-antes que la acción B, se garantiza que B observe los efectos de A, sujetos a escrituras posteriores. El orden del programa, el uso del mismo monitor, el acceso a campos volatile y ciertas operaciones de hilos y bibliotecas establecen estas relaciones. Sin una ordenación pertinente, un programa no puede suponer que un hilo vea las escrituras de otro.

condición de carrera

La corrección depende de la temporización

Se produce una condición de carrera cuando la corrección de un cálculo depende de cómo el entorno de ejecución intercala las operaciones de distintos hilos. Algunos ejemplos son incrementar un contador compartido mediante pasos separados de lectura y escritura, o comprobar que una caché está vacía antes de llenarla. La sincronización, el confinamiento o una operación atómica adecuada eliminan la dependencia de una temporización favorable.

confinamiento de hilos

Mantener un objeto dentro de un único hilo

El confinamiento de hilos es una estrategia de diseño en la que un único hilo accede a un objeto. Como su estado mutable no se comparte, esos accesos no requieren sincronización. El confinamiento puede surgir de variables locales, de un subsistema de un solo hilo, como el hilo de eventos de Swing, o de almacenamiento por hilo, como ThreadLocal. El objeto no debe escapar del ámbito previsto.

publicación segura

Hacer visible un objeto inicializado

La publicación segura garantiza que otro hilo vea un objeto en el estado establecido antes de compartirlo. Entre los mecanismos habituales se encuentran la inicialización estática, guardar la referencia en un campo volatile, proteger el acceso con un bloqueo o transferir el objeto mediante una colección o cola segura para hilos. Si el objeto es mutable, la publicación segura por sí sola no protege los cambios posteriores.

patrón productor-consumidor

Separar la creación del trabajo de su procesamiento

El patrón productor-consumidor separa la creación del trabajo de su ejecución. Los productores colocan elementos de trabajo en una cola compartida, y los consumidores los recuperan y procesan de forma independiente. Una cola bloqueante puede hacer que los consumidores esperen cuando no hay trabajo disponible y ralentizar a los productores cuando se llena una cola limitada, lo que proporciona coordinación y un mecanismo para gestionar la sobrecarga.

ley de Amdahl

Limita la aceleración obtenida mediante el trabajo paralelo

La ley de Amdahl estima la aceleración máxima que puede obtenerse con procesadores adicionales cuando una parte del cálculo debe seguir ejecutándose en serie. Si la fracción F es serial, la aceleración teórica en N procesadores está limitada por la parte serial y, a medida que N crece sin límite, el máximo se aproxima a 1/F. Esto pone de relieve por qué los bloqueos compartidos, las colas y la gestión de resultados pueden limitar la escalabilidad.

comparar e intercambiar (compare-and-swap)

Actualizar solo si el valor no ha cambiado

La operación comparar e intercambiar (compare-and-swap), o CAS, compara atómicamente una ubicación de memoria con un valor esperado y lo reemplaza solo si el valor aún coincide. Un invocador puede leer un valor, calcular una actualización y volver a intentarlo si otro hilo cambió antes el valor. CAS permite usar variables atómicas y algoritmos no bloqueantes, pero los reintentos repetidos bajo una contención elevada pueden resultar costosos.

interbloqueo por inanición de hilos

Los trabajadores esperan trabajo en cola

El interbloqueo por inanición de hilos se produce cuando las tareas de un ejecutor limitado se bloquean mientras esperan otras tareas que no pueden iniciarse porque todos los hilos del ejecutor están ocupados. Un ejecutor de un solo hilo muestra con claridad el caso más sencillo: si su única tarea envía una segunda tarea y espera su resultado, la segunda tarea permanece en cola indefinidamente. Evite dependencias entre tareas y políticas de ejecución incompatibles.

Preguntas frecuentes

¿De qué trata Java Concurrency in Practice?

  • Enfoque en la concurrencia: Java Concurrency in Practice, de Brian Goetz, es una guía exhaustiva para escribir aplicaciones concurrentes en Java que aborda las complejidades y los desafíos de la programación multihilo.
  • Técnicas prácticas: Trata conceptos fundamentales como la seguridad de hilos, la sincronización y el Modelo de memoria de Java, y ofrece técnicas prácticas para desarrollar, probar y depurar programas multihilo.
  • Público destinatario: El libro es adecuado para desarrolladores de Java de todos los niveles y ofrece ideas sobre patrones de diseño concurrente y ejemplos del mundo real para mejorar la comprensión.

¿Por qué debería leer Java Concurrency in Practice?

  • Esencial para desarrolladores de Java: Comprender la concurrencia es crucial para crear aplicaciones Java eficientes y con buena capacidad de respuesta, por lo que este libro es imprescindible para quienes desarrollan.
  • Perspectivas de un experto: Escrito por Brian Goetz, una autoridad destacada en concurrencia de Java, el libro ofrece perspectivas profundas y prácticas sobre el diseño y la implementación de características de concurrencia.
  • Aplicaciones del mundo real: Incluye situaciones y soluciones del mundo real que ayudan a los desarrolladores a aplicar directamente los conceptos en sus proyectos y a mejorar la calidad del código.

¿Cuáles son las principales conclusiones de Java Concurrency in Practice?

  • Principios de seguridad de hilos: Destaca la gestión del acceso al estado mutable compartido mediante sincronización y bloqueos para garantizar la seguridad de los hilos.
  • Patrones de diseño: Presenta patrones de diseño como el patrón de monitores de Java y el confinamiento de hilos para estructurar eficazmente aplicaciones concurrentes.
  • Consideraciones de rendimiento: Trata técnicas de optimización del rendimiento, como minimizar la contención de bloqueos y comprender la ley de Amdahl para lograr escalabilidad.

¿Qué significa la seguridad de hilos según Java Concurrency in Practice?

  • Definición de seguridad de hilos: Una clase es segura para hilos si se comporta correctamente cuando varios hilos acceden a ella de forma concurrente y mantiene un estado coherente y válido.
  • Importancia de la sincronización: Para lograr la seguridad de hilos se necesitan mecanismos de sincronización que coordinen el acceso al estado mutable compartido.
  • Invariantes y poscondiciones: Las clases seguras para hilos deben mantener sus invariantes y poscondiciones, garantizando la validez del estado con independencia del acceso de los hilos.

¿Cómo define Java Concurrency in Practice el Modelo de memoria de Java?

  • Propósito del modelo de memoria: Define cómo interactúan los hilos a través de la memoria y ofrece garantías sobre la visibilidad y la ordenación de las operaciones en la programación concurrente.
  • Garantías de visibilidad: Sin sincronización, los cambios realizados por un hilo pueden no ser visibles para los demás, lo que subraya la necesidad de una sincronización adecuada.
  • Atomicidad y ordenación: Explica cómo el modelo de memoria permite optimizaciones que afectan a la atomicidad y la ordenación, y destaca la importancia de comprender sus implicaciones.

¿Qué es el marco Executor en Java Concurrency in Practice?

  • Gestión de tareas simplificada: El marco Executor desvincula el envío de tareas de la política de ejecución, lo que permite gestionar tareas concurrentes con flexibilidad.
  • Uso de grupos de hilos: Permite utilizar grupos de hilos y mejora la gestión de recursos al reutilizar hilos y reducir la sobrecarga.
  • Concurrencia simplificada: Al usar el marco Executor, los desarrolladores pueden evitar las complejidades de gestionar hilos y centrarse en definir las tareas y las políticas de ejecución.

¿Cuáles son algunos peligros habituales de la concurrencia que se analizan en Java Concurrency in Practice?

  • Condiciones de carrera: Se producen cuando la corrección de un cálculo depende de la temporización relativa de los hilos, lo que da lugar a un comportamiento inesperado.
  • Interbloqueos: Se producen cuando los hilos quedan bloqueados indefinidamente, cada uno esperando que otro libere un recurso; el libro ofrece estrategias para evitarlos.
  • Problemas de visibilidad: Surgen cuando un hilo modifica una variable, pero otro no ve el valor actualizado, lo que recalca la necesidad de una sincronización adecuada.

¿Cómo puedo evitar los interbloqueos según Java Concurrency in Practice?

  • Orden coherente de los bloqueos: Adquiere los bloqueos siguiendo un orden global coherente para evitar dependencias cíclicas entre hilos.
  • Usa llamadas abiertas: Evita llamar a métodos externos mientras mantienes bloqueos, para prevenir dependencias inesperadas e interbloqueos potenciales.
  • Intentos de bloqueo con tiempo límite: Implementa intentos de bloqueo con tiempo límite mediante bloqueos explícitos para recuperar el control si no se puede adquirir un bloqueo en un plazo razonable.

¿Cuáles son las principales técnicas de sincronización que se analizan en Java Concurrency in Practice?

  • Bloqueos intrínsecos: Son la forma más sencilla de sincronización en Java; proporcionan exclusión mutua en secciones críticas, pero pueden provocar contención.
  • Bloqueos explícitos: ReentrantLock ofrece más flexibilidad que los bloqueos intrínsecos y permite adquirirlos con tiempo límite y de forma interrumpible.
  • Variables de condición: Permiten que los hilos esperen a que se cumplan ciertas condiciones y son fundamentales para implementar patrones como el de productor-consumidor.

¿Qué importancia tiene la ley de Amdahl en Java Concurrency in Practice?

  • Límite del rendimiento: Muestra que la aceleración máxima de un programa está limitada por la parte serial de la carga de trabajo.
  • Perspectiva sobre la escalabilidad: Ayuda a los desarrolladores a comprender el impacto de la ejecución serial en el rendimiento y la escalabilidad generales de una aplicación.
  • Orienta los esfuerzos de optimización: Identificar los componentes seriales ayuda a enfocar los esfuerzos de optimización para mejorar la escalabilidad.

¿Cuáles son las mejores citas de Java Concurrency in Practice y qué significan?

  • «El coste de la equidad se debe principalmente al bloqueo de hilos»: Destaca que los algoritmos equitativos pueden causar problemas de rendimiento por el aumento de los bloqueos, por lo que es necesario equilibrar equidad y rendimiento.
  • «Probar la corrección de programas concurrentes puede ser extremadamente difícil»: Refleja las dificultades de garantizar que las aplicaciones concurrentes se comporten según lo previsto y subraya la importancia de realizar pruebas rigurosas.
  • «El objetivo de las pruebas no es tanto encontrar errores como aumentar la confianza en que el código funciona según lo previsto»: Anima a centrarse en crear sistemas fiables, en lugar de limitarse a identificar errores.

¿Qué temas avanzados se tratan en Java Concurrency in Practice?

  • Bloqueos explícitos y variables de condición: Mecanismos avanzados de bloqueo como ReentrantLock ofrecen un mayor control sobre la sincronización.
  • Algoritmos no bloqueantes: Usan operaciones atómicas en lugar de bloqueos y ofrecen ventajas de rendimiento y escalabilidad.
  • El Modelo de memoria de Java: Analiza en profundidad cómo rige la visibilidad y la ordenación de las operaciones, algo esencial para escribir aplicaciones multihilo correctas.

Sobre el autor

Brian Goetz es una autoridad reconocida en concurrencia y optimización del rendimiento en Java. Es arquitecto del lenguaje Java en Oracle, donde desempeña un papel crucial en la evolución del lenguaje de programación Java. Goetz ha contribuido de manera significativa a las bibliotecas de concurrencia y a las características del lenguaje Java. La comunidad de Java lo respeta ampliamente por sus profundos conocimientos técnicos y su capacidad para explicar conceptos complejos con claridad. Además de ser autor de «Java Concurrency in Practice», Goetz ha escrito numerosos artículos sobre programación en Java y participa con frecuencia como ponente en conferencias tecnológicas. Su trabajo ha influido enormemente en el desarrollo de las prácticas de programación concurrente en Java.

Descargar PDF

Para guardar este resumen de Java Concurrency in Practice para más tarde, descarga el PDF gratis. Puedes imprimirlo o leerlo sin conexión cuando quieras.
Download PDF

Descargar EPUB

Para leer este resumen de Java Concurrency in Practice en tu dispositivo o aplicación de lectura, descarga el EPUB gratis. El formato de libro digital .epub es ideal para leer libros electrónicos en teléfonos, tabletas y lectores electrónicos.
Download EPUB
¿Quieres leer el libro completo?
Seguir
Escuchar
Inicio
Swipe
Biblio
App
Prueba el acceso completo por 3 días
Escucha, guarda y mucho más
Comparar funciones Gratis Pro
📖 Leer resúmenes
Lee resúmenes ilimitados. Los usuarios gratuitos obtienen 3 al mes
🎧 Escuchar resúmenes
Escucha resúmenes ilimitados en 40 idiomas
—
❤️ Marcadores ilimitados
Usuarios gratuitos limitados a 4
—
📜 Historial ilimitado
Usuarios gratuitos limitados a 4
—
📥 Descargas ilimitadas
Usuarios gratuitos limitados a 1
—
Cronología sin riesgo
Hoy: Obtén acceso instantáneo
Escucha resúmenes completos de más de 26.000 libros. ¡Son más de 12.000 horas de audio!
Día 2: Recordatorio de prueba
Te enviaremos una notificación de que tu prueba está por terminar.
Día 3: Tu suscripción comienza
Se te cobrará el 24 nov,
cancela en cualquier momento antes.
Consume 2.8× More Books
2.8× libros más Escucha Lectura
Nuestros usuarios nos adoran
600,000+ lectores
Trustpilot Rating
TrustPilot
4.6 Excelente
Este sitio es un antes y un después. He leído resúmenes como nunca antes. Lo recomiendo muchísimo.
— Dave G
Vale cada centavo y cada minuto, y está muy bien hecho. Nunca había visto esta calidad de resúmenes en otros sitios. ¡Muy útil!
— Em
¡Muy recomendado! Servicio fantástico. Perfecto para quienes quieren algo más que una sinopsis, pero no todos los detalles de un audiolibro completo.
— Greg M
Ahorra un 62%
Anual
$119.88 $44.99/año/año
$3.75/mes
Mensual
$9.99/mes
Inicia tu prueba gratuita de 3 días
3 días gratis, luego $44.99/año. Cancela cuando quieras.
Unlock a world of fiction & nonfiction books
Más de 26.000 libros por el precio de 2
Lee cualquier libro en 10 minutos
Descubre libros nuevos como en Tinder
Solicita cualquier libro si no está resumido
Lee más libros que cualquiera que conozcas
La app nº 1 para amantes de los libros
Lifelike & immersive summaries
Garantía de devolución de 30 días
Descarga resúmenes en EPUB o PDF
Cancela en cualquier momento con unos clics

¿Por qué solo un resumen?

Escáner
Busca un código de barras para escanear

⭐
⭐
⭐
Tenemos un regalo especial para ti
Abrir
38% de descuento
DESCUENTO PARA TI
⭐
⭐
⭐
$79.99
$49.99/año
Solo $4.16 al mes
Continuar
Empieza con 2 toques y cancela fácilmente
Configuración
General
Widget
Cargando...