Contexto

En sistemas empresariales modernos, procesar peticiones secuencialmente conduce a cuellos de botella severos. La programación concurrente permite despachar tareas de E/S o cómputo aprovechando los núcleos del procesador.

Sin embargo, cuando múltiples hilos acceden y modifican el mismo objeto en el Heap compartido sin coordinación, surge el peligro de las condiciones de carrera (race conditions): Operaciones compuestas como contador++ o saldo = saldo - monto involucran lectura, cálculo y escritura. Si los hilos intercalan estos pasos, se producen inconsistencias o pérdidas de datos invisibles al compilador.

Para resolver esto de forma profesional:

  1. Se utiliza un ExecutorService para reutilizar un conjunto acotado de hilos (Thread Pool), evitando el costo prohibitivo de instanciar miles de hilos del sistema operativo.
  2. Se utilizan tareas Callable<V> que devuelven resultados mediante Future<V>.
  3. Se protegen las secciones críticas mediante exclusión mutua (synchronized) o primitivas atómicas.

Consigna

Vas a implementar un procesador concurrente de transacciones bancarias, evidenciando la importancia de la sincronización y la correcta administración de hilos.

1. Modelo de Dominio Seguro

public class CuentaBancariaSegura {
    private double saldo;
    private int operaciones;

    public CuentaBancariaSegura(double saldoInicial) {
        this.saldo = saldoInicial;
    }

    public synchronized boolean procesarMovimiento(double monto) {
        if (monto < 0 && saldo + monto < 0) {
            return false; // Fondos insuficientes
        }
        this.saldo += monto;
        this.operaciones++;
        return true;
    }

    public synchronized double getSaldo() {
        return saldo;
    }
}

2. Tarea Concurrente con Callable

public class TareaTransaccion implements Callable<ResultadoTransaccion> {
    private final int id;
    private final double monto;
    private final CuentaBancariaSegura cuenta;

    // constructor...

    @Override
    public ResultadoTransaccion call() throws Exception {
        // Simular latencia de validación externa
        Thread.sleep(50);
        boolean exito = cuenta.procesarMovimiento(monto);
        return new ResultadoTransaccion(id, monto, exito);
    }
}

3. Orquestación con ExecutorService y Apagado Ordenado

  • Crear el pool: ExecutorService executor = Executors.newFixedThreadPool(4);
  • Enviar las tareas con executor.submit(...) acumulando los Future<ResultadoTransaccion>.
  • Protocolo de parada (Graceful Shutdown):
    executor.shutdown();
    try {
        if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
            executor.shutdownNow();
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }