Evita el Uso de Métodos Sincronizados

La sincronización (synchronized) es una técnica utilizada en programación concurrente para evitar condiciones de carrera cuando varios hilos acceden a una misma sección crítica del código. Sin embargo, los métodos sincronizados pueden reducir drásticamente el rendimiento de una aplicación debido a los bloqueos innecesarios y la pérdida de paralelismo.

✅ Razones para evitar métodos sincronizados:

Reducen el rendimiento al bloquear el acceso de múltiples hilos.
Pueden causar bloqueos innecesarios (deadlocks) si no se manejan correctamente.
Alternativas más eficientes como Atomic Variables, Locks, Concurrent Collections o ThreadLocal.

Ejemplo incorrecto: Uso de métodos sincronizados

Aquí se usa synchronized en un método completo, lo que bloquea todos los accesos concurrentes, incluso cuando no es necesario.

1public class Banco {
2    private int saldo = 1000;
3
4    public synchronized void retirar(int cantidad) { // Bloquea toda la ejecución del método
5        if (saldo >= cantidad) {
6            saldo -= cantidad;
7            System.out.println("Retiro exitoso. Saldo restante: " + saldo);
8        } else {
9            System.out.println("Saldo insuficiente.");
10        }
11    }
12}

Problema:

Se bloquea el método completo, lo que impide que múltiples hilos accedan a la cuenta simultáneamente.
Incluso operaciones de solo lectura se ven afectadas, ralentizando el sistema.

Ejemplo optimizado: Sincronización solo en la sección crítica

En lugar de sincronizar el método completo, podemos sincronizar solo la sección crítica para mejorar el rendimiento.

1import java.util.concurrent.locks.ReentrantLock;
2
3public class Banco {
4    private int saldo = 1000;
5    private final ReentrantLock lock = new ReentrantLock(); // Uso de un lock en lugar de synchronized
6
7    public void retirar(int cantidad) {
8        lock.lock(); // Bloqueo solo la sección crítica
9        try {
10            if (saldo >= cantidad) {
11                saldo -= cantidad;
12                System.out.println("Retiro exitoso. Saldo restante: " + saldo);
13            } else {
14                System.out.println("Saldo insuficiente.");
15            }
16        } finally {
17            lock.unlock(); // Liberar el lock al final
18        }
19    }
20}

✅ Beneficios de esta optimización:

Mejor rendimiento al evitar bloqueos innecesarios.
Permite más concurrencia, ya que otros hilos pueden leer el saldo sin esperar.
Evita bloqueos innecesarios y deadlocks.

Ejemplo incorrecto: Uso de métodos sincronizados en lectura

A continuación, un error común: bloquear un método de solo lectura innecesariamente.

1public class Banco {
2    private int saldo = 1000;
3
4    public synchronized int obtenerSaldo() { // Bloqueo innecesario
5        return saldo;
6    }
7}

Problema:

El método solo lee datos, pero aún así se bloquea para otros hilos.
Esto reduce la escalabilidad de la aplicación, ya que múltiples hilos podrían leer el saldo sin interferirse.

Ejemplo optimizado: Uso de `volatile` para lecturas concurrentes

Podemos evitar synchronized en métodos de solo lectura usando volatile.

1public class Banco {
2    private volatile int saldo = 1000; // Uso de volatile para garantizar visibilidad entre hilos
3
4    public int obtenerSaldo() {
5        return saldo; // No necesita sincronización
6    }
7}

✅ Beneficios:

No bloquea el acceso a la lectura.
Mejor rendimiento, ya que múltiples hilos pueden leer el saldo sin problemas.
Evita bloqueos innecesarios, permitiendo una mayor concurrencia.

Ejemplo incorrecto: Uso de `synchronized` en colecciones compartidas

El uso de colecciones sincronizadas puede ralentizar la ejecución si hay muchas operaciones de lectura y escritura.

1import java.util.*;
2
3public class Ejemplo {
4    private final List<Integer> lista = Collections.synchronizedList(new ArrayList<>());
5
6    public synchronized void agregar(int valor) { // Bloqueo innecesario en cada inserción
7        lista.add(valor);
8    }
9}

Problema:

Cada inserción bloquea toda la estructura de datos, reduciendo la eficiencia.
En entornos concurrentes grandes, el acceso se vuelve lento.

Ejemplo optimizado: Uso de `Concurrent Collections`

Podemos utilizar ConcurrentHashMap o CopyOnWriteArrayList para mejorar la eficiencia.

1import java.util.concurrent.CopyOnWriteArrayList;
2
3public class Ejemplo {
4    private final CopyOnWriteArrayList<Integer> lista = new CopyOnWriteArrayList<>();
5
6    public void agregar(int valor) {
7        lista.add(valor); // No es necesario sincronizar manualmente
8    }
9}

✅ Beneficios:

Mejor rendimiento, ya que no bloquea la estructura de datos completa.
Ideal para entornos de alta concurrencia.
Evita bloqueos innecesarios en estructuras de datos.

Ejemplo incorrecto: Sincronización en acceso a variables simples

Sincronizar el acceso a variables simples es innecesario y ralentiza el código.

1public class Contador {
2    private int valor = 0;
3
4    public synchronized void incrementar() { // Bloqueo innecesario
5        valor++;
6    }
7
8    public synchronized int obtenerValor() { // Bloqueo innecesario
9        return valor;
10    }
11}

Problema:

Cada acceso bloquea la variable, reduciendo la eficiencia.
Alternativas más eficientes están disponibles.

Ejemplo optimizado: Uso de `AtomicInteger`

Podemos usar AtomicInteger, que es más rápido y seguro para el acceso concurrente.

1import java.util.concurrent.atomic.AtomicInteger;
2
3public class Contador {
4    private final AtomicInteger valor = new AtomicInteger(0);
5
6    public void incrementar() {
7        valor.incrementAndGet(); // Operación atómica sin necesidad de synchronized
8    }
9
10    public int obtenerValor() {
11        return valor.get(); // No bloquea la lectura
12    }
13}

✅ Beneficios:

Mayor rendimiento en entornos concurrentes.
Evita la sobrecarga de sincronización.
Ideal para contadores y operaciones simples.

Conclusión

🎯 Reglas clave para evitar `synchronized`

✅ Evita sincronizar métodos completos, sincroniza solo la sección crítica del código.
✅ Usa ReentrantLock en lugar de synchronized para más flexibilidad y mejor rendimiento.
✅ Para operaciones de solo lectura, usa volatile en lugar de sincronización.
✅ Utiliza estructuras concurrentes como ConcurrentHashMap y CopyOnWriteArrayList en lugar de listas sincronizadas manualmente.
✅ Usa AtomicInteger y otras clases atómicas en lugar de synchronized en variables simples.

Siguiendo estas prácticas, logramos un código más rápido, eficiente y escalable en aplicaciones multihilo. 🚀

Optimización de código