Sincronizar

Desmitificando la palabra clave synchronized en Java

Si alguna vez has escrito código multihilo en Java, seguramente te has topado con synchronized. A primera vista parece una varita mágica para resolver todos los problemas de concurrencia, pero como sucede con casi cualquier solución aparentemente mágica, tiene matices y límites importantes.

Qué hace synchronized

La palabra clave synchronized es el mecanismo incorporado de Java para garantizar exclusión mutua y visibilidad de memoria. En términos simples, solo un hilo a la vez puede ejecutar un método o bloque sincronizado que se bloquee sobre el mismo objeto. Para lograrlo, adquiere un monitor o bloqueo intrínseco del objeto; los demás hilos que intentan adquirir ese mismo bloqueo deben esperar hasta que se libere.

Cuándo funciona bien

synchronized resulta útil cuando varios hilos acceden y modifican datos compartidos, cuando quieres evitar condiciones de carrera y cuando necesitas que los cambios de un hilo sean visibles para los demás. Puedes proteger métodos de instancia bloqueando sobre this, métodos estáticos bloqueando sobre el objeto clase y también secciones concretas con synchronized(objeto) { ... } aplicando el candado a un objeto explícito.

Cuándo no ayuda

No es una bala de plata. No sirve si los hilos se sincronizan sobre objetos distintos porque se usa el bloqueo equivocado, no evita por sí mismo interbloqueos, puede perjudicar el rendimiento si hay mucha contención, es innecesario con recursos no compartidos como variables locales y no ofrece sincronización entre distintas JVM.

Ventajas y desventajas en la práctica

Seguridad de hilos: pro, asegura que un único hilo acceda al recurso compartido en cada momento; contra, usar un bloqueo incorrecto crea una falsa sensación de seguridad.

Simplicidad: pro, basta con la palabra clave synchronized; contra, es fácil abusar de ella y provocar errores sutiles.

Visibilidad de memoria: pro, garantiza que las escrituras de un hilo se publiquen para los demás; contra, no evita fallos lógicos como interbloqueo o inanición.

Flexibilidad: pro, permite sincronizar métodos completos o secciones críticas; contra, sincronizar de forma demasiado amplia reduce el desempeño.

Fiabilidad: pro, está incorporado y probado por la JVM, sin librerías extra; contra, puede convertirse en cuello de botella si muchos hilos compiten por el mismo candado.

Granularidad: pro, funciona muy bien para secciones críticas pequeñas; contra, un bloqueo de grano grueso ralentiza y limita la escalabilidad.

Ejemplo de contador sin y con synchronized

Sin sincronización aparece una condición de carrera. Dos hilos leen el mismo valor, lo actualizan y sobrescriben el resultado del otro, provocando actualizaciones perdidas. Código ilustrativo:

class Counter { private int count = 0; public void increment() { count++; } public int getCount() { return count; } } public class RaceConditionDemo { public static void main(String[] args) throws InterruptedException { Counter counter = new Counter(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { counter.increment(); } }; Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(counter.getCount()); } }

Qué ocurre en la línea temporal sin sincronización

El hilo T1 empieza y lee count en 0. Antes de escribir, T2 también lee count en 0. T1 escribe 1 y poco después T2 escribe 1, sobrescribiendo el valor anterior. El resultado final es 1 en lugar de 2, un ejemplo clásico de actualización perdida.

Con sincronización, solo un hilo entra a la sección crítica a la vez, evitando la carrera y garantizando la visibilidad de memoria. Código ilustrativo:

class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } } public class SynchronizedDemo { public static void main(String[] args) throws InterruptedException { Counter counter = new Counter(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { counter.increment(); } }; Thread t1 = new Thread(task); Thread t2 = new Thread(task); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(counter.getCount()); } }

Qué ocurre en la línea temporal con sincronización

T1 adquiere el candado, lee count, actualiza y libera el candado. Solo entonces T2 puede adquirirlo, leer el nuevo valor y actualizarlo. No hay sobrescrituras y el resultado es consistente.

Buenas prácticas con synchronized

Elige el candado correcto y documenta qué estado protege. Reduce la sección crítica al mínimo necesario. Evita bloqueos anidados para disminuir el riesgo de interbloqueo. Cuando necesites capacidades adicionales como intentos temporizados o orden justo, considera ReentrantLock. Para contadores simples valora AtomicInteger. Para estructuras compartidas usa colecciones concurrentes y combina con volatile cuando solo necesites visibilidad sin exclusión.

Cómo te ayuda Q2BSTUDIO

En Q2BSTUDIO somos una empresa de desarrollo de software que diseña aplicaciones a medida y software a medida con alto rendimiento, escalabilidad y seguridad. Integramos patrones de concurrencia, pruebas de carga y ciberseguridad desde el inicio para que tus productos sean robustos. Si buscas impulsar tu proyecto, conoce nuestro servicio de desarrollo de aplicaciones y software a medida o acelera tu entrega y calidad con automatización de procesos.

Nuestro portafolio incluye inteligencia artificial e ia para empresas, diseño de agentes IA, servicios cloud aws y azure, servicios inteligencia de negocio y analítica con power bi, además de ciberseguridad avanzada y pentesting. Desde arquitectura cloud nativa hasta observabilidad, entregamos soluciones preparadas para producción, con pipelines automatizados y protección end to end.

Palabras clave para ayudarte a encontrar lo que necesitas

aplicaciones a medida, software a medida, inteligencia artificial, ia para empresas, agentes IA, ciberseguridad, servicios cloud aws y azure, servicios inteligencia de negocio, power bi