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:
- Se utiliza un
ExecutorServicepara reutilizar un conjunto acotado de hilos (Thread Pool), evitando el costo prohibitivo de instanciar miles de hilos del sistema operativo. - Se utilizan tareas
Callable<V>que devuelven resultados medianteFuture<V>. - 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 losFuture<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(); }