import java.net.ServerSocket;
import java.net.Socket;

// El constructor hace el "bind": reserva el puerto 9090 para este proceso.
try (ServerSocket servidor = new ServerSocket(9090)) {

    System.out.println("Escuchando en el puerto " + servidor.getLocalPort());

    // accept() BLOQUEA hasta que llega una conexion.
    // Cuando vuelve, devuelve un Socket YA CONECTADO al cliente.
    Socket conexion = servidor.accept();

    System.out.println("Cliente conectado desde " + conexion.getRemoteSocketAddress());

    // A partir de aqui, 'conexion' es exactamente el Socket de 09-02:
    // getInputStream(), getOutputStream(), setSoTimeout(), close()...
}

// 1. Puerto. Lo minimo.
new ServerSocket(9090);

// 2. Puerto + backlog: tamano de la cola de conexiones pendientes.
new ServerSocket(9090, 100);

// 3. Puerto + backlog + direccion de escucha.
new ServerSocket(9090, 100, InetAddress.getByName("127.0.0.1"));

// 4. Sin conectar, para configurar antes del bind (lo veremos en el apartado 4).
ServerSocket s = new ServerSocket();
s.setReuseAddress(true);
s.bind(new InetSocketAddress(9090), 100);

                 cola de pendientes (backlog = 3)
  clientes  -->  [ conn ][ conn ][ conn ]  -->  accept()  -->  tu codigo
  nuevos                                                       (uno cada vez)

  Si la cola esta llena, el SO rechaza las conexiones nuevas
  y el cliente recibe ConnectException: Connection refused.

try (ServerSocket servidor = new ServerSocket(0)) {
    int puertoReal = servidor.getLocalPort();     // por ejemplo, 43127
    System.out.println("El sistema me ha dado el puerto " + puertoReal);
}

Socket conexion = servidor.accept();

servidor.setSoTimeout(1000);        // sondeo cada segundo
while (ejecutando) {
    try {
        Socket conexion = servidor.accept();
        atender(conexion);
    } catch (SocketTimeoutException e) {
        // Un segundo sin conexiones: aprovechamos para comprobar
        // la bandera de parada y volvemos a esperar.
        continue;
    }
}

Exception in thread "main" java.net.BindException: Address already in use
	at java.base/sun.nio.ch.Net.bind0(Native Method)
	at java.base/java.net.ServerSocket.bind(ServerSocket.java:395)
	at java.base/java.net.ServerSocket.<init>(ServerSocket.java:262)

ss -tlnp | grep 9090
# LISTEN 0 50 0.0.0.0:9090 0.0.0.0:* users:(("java",pid=4711,fd=7))

kill 4711          # y si se resiste, kill -9 4711

lsof -i :9090
netstat -an | grep 9090

// La forma correcta: crear SIN atar, configurar, y despues atar.
ServerSocket servidor = new ServerSocket();
servidor.setReuseAddress(true);                       // ANTES del bind
servidor.bind(new InetSocketAddress(9090), 100);

package com.nexussoftware.bibliotech.red;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.logging.Logger;

/**
 * Servidor de eco SECUENCIAL: atiende a un cliente cada vez.
 * Sirve para demostrar el limite del modelo, no para usarlo.
 */
public class ServidorSecuencial {

    private static final Logger LOG = Logger.getLogger(ServidorSecuencial.class.getName());

    public static void main(String[] args) throws IOException {
        ServerSocket servidor = new ServerSocket();
        servidor.setReuseAddress(true);
        servidor.bind(new InetSocketAddress(9090), 50);

        LOG.info("Servidor secuencial escuchando en 9090");

        try (servidor) {
            while (true) {
                // Se acepta UNA conexion...
                Socket conexion = servidor.accept();
                LOG.info(() -> "Conexion de " + conexion.getRemoteSocketAddress());

                // ...y se atiende ENTERA antes de volver al accept().
                // Mientras dura esta conversacion, nadie mas es atendido.
                try (conexion) {
                    conexion.setSoTimeout(60_000);
                    atender(conexion);
                } catch (IOException e) {
                    LOG.warning("Fallo atendiendo la conexion: " + e.getMessage());
                }

                LOG.info("Conexion terminada; vuelvo al accept()");
            }
        }
    }

    private static void atender(Socket conexion) throws IOException {
        BufferedReader lector = new BufferedReader(
                new InputStreamReader(conexion.getInputStream(), StandardCharsets.UTF_8));
        PrintWriter escritor = new PrintWriter(
                new java.io.BufferedWriter(
                        new java.io.OutputStreamWriter(conexion.getOutputStream(),
                                StandardCharsets.UTF_8)),
                true);

        escritor.println("200 SERVIDOR DE ECO. Escribe SALIR para terminar.");

        String linea;
        while ((linea = lector.readLine()) != null) {
            if (linea.equalsIgnoreCase("SALIR")) {
                escritor.println("221 ADIOS");
                return;
            }
            escritor.println("ECO: " + linea);
        }
        // readLine() ha devuelto null: el cliente cerro sin despedirse.
    }
}

TERMINAL 1 (primer cliente)          TERMINAL 2 (segundo cliente)
------------------------------       ------------------------------
$ telnet localhost 9090              $ telnet localhost 9090
Trying 127.0.0.1...                  Trying 127.0.0.1...
Connected to localhost.              Connected to localhost.
200 SERVIDOR DE ECO. Escribe...      _
hola                                 (nada. No hay saludo.
ECO: hola                             La conexion TCP esta hecha,
                                      pero el servidor no ha llamado
                                      a accept() y no lee nada)

TERMINAL 1                           TERMINAL 2
------------------------------       ------------------------------
SALIR                                200 SERVIDOR DE ECO. Escribe...
221 ADIOS                            (¡ahora si! Al liberarse el hilo,
Connection closed.                    el accept() recoge esta conexion)

INFO: Servidor secuencial escuchando en 9090
INFO: Conexion de /127.0.0.1:52310
INFO: Conexion terminada; vuelvo al accept()
INFO: Conexion de /127.0.0.1:52311

while (true) {
    Socket conexion = servidor.accept();

    // Un hilo nuevo por conexion. El bucle vuelve al accept() al instante.
    Thread hilo = new Thread(() -> {
        try (conexion) {
            atender(conexion);
        } catch (IOException e) {
            LOG.warning("Fallo atendiendo: " + e.getMessage());
        }
    }, "cliente-" + conexion.getPort());
    hilo.start();
}

package com.nexussoftware.bibliotech.red;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Fabrica de hilos con nombres legibles. Un hilo llamado "bibliotech-cliente-3"
 * en un volcado de hilos o en una linea de log vale mil veces mas que
 * "pool-1-thread-3". Esto es 08-02 y 08-05 aplicados.
 */
public class FabricaHilosServidor implements ThreadFactory {

    private final String prefijo;
    private final AtomicInteger contador = new AtomicInteger(1);

    public FabricaHilosServidor(String prefijo) {
        this.prefijo = prefijo;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread hilo = new Thread(r, prefijo + "-" + contador.getAndIncrement());
        // NO daemon: queremos que el apagado sea explicito y ordenado,
        // no que la JVM mate conversaciones a medias al terminar el main.
        hilo.setDaemon(false);
        return hilo;
    }
}

// Pool acotado con ThreadPoolExecutor: control total sobre el comportamiento.
ThreadPoolExecutor pool = new ThreadPoolExecutor(
        8,                                     // hilos nucleo: siempre vivos
        8,                                     // maximo: acotado, sin sorpresas
        60L, TimeUnit.SECONDS,                 // tiempo ocioso antes de morir
        new LinkedBlockingQueue<>(100),        // cola ACOTADA de tareas en espera
        new FabricaHilosServidor("bibliotech-cliente"),
        new ThreadPoolExecutor.AbortPolicy()); // que hacer si no cabe

try {
    pool.execute(() -> atenderConexion(conexion));
} catch (RejectedExecutionException e) {
    // El servidor esta saturado. Se lo decimos al cliente y cerramos.
    // Rechazar rapido es MEJOR que aceptar y no responder.
    rechazarEducadamente(conexion, "503 SERVIDOR SATURADO");
}

private volatile boolean ejecutando = true;
private ServerSocket servidor;

/** Bucle principal. Se ejecuta en el hilo aceptador. */
public void ejecutar() {
    while (ejecutando) {
        try {
            Socket conexion = servidor.accept();
            pool.execute(() -> atender(conexion));

        } catch (SocketException e) {
            // Puede ser un fallo real O nuestro propio cierre.
            // La bandera 'ejecutando' distingue los dos casos:
            // sin ella, un apagado normal aparece en el log como un error grave.
            if (!ejecutando) {
                LOG.info("ServerSocket cerrado: fin ordenado del bucle de aceptacion");
                break;
            }
            LOG.log(Level.SEVERE, "Fallo inesperado en accept()", e);
            break;

        } catch (IOException e) {
            // Un fallo aceptando UNA conexion no debe tumbar el servidor:
            // se registra y se sigue aceptando.
            LOG.log(Level.WARNING, "Error aceptando una conexion", e);
        }
    }
}

/** Se llama desde otro hilo (menu, shutdown hook, senal). */
public void parar() {
    ejecutando = false;              // 1. bandera volatile: se ve desde el otro hilo
    cerrarSilenciosamente(servidor); // 2. esto desbloquea el accept() al instante
    // 3. y despues, el apagado en dos fases del pool
}

public void parar() {
    ejecutando = false;
    cerrarSilenciosamente(servidor);

    // FASE 1: no se aceptan tareas nuevas, pero las que estan en curso terminan.
    pool.shutdown();
    try {
        // Damos un plazo razonable para que las conversaciones acaben solas.
        if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
            LOG.warning("Conversaciones aun activas tras 10 s: se fuerza el cierre");

            // FASE 2: interrupcion de los hilos que queden.
            pool.shutdownNow();

            if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                LOG.severe("El pool no ha terminado; hay hilos atascados");
            }
        }
    } catch (InterruptedException e) {
        // Nos han interrumpido esperando: forzamos y RESTAURAMOS la bandera.
        pool.shutdownNow();
        Thread.currentThread().interrupt();    // 08-02: nunca se traga la interrupcion
    }
}

// Dentro del hilo que atiende a Marta, y a la vez dentro del que atiende a Diego,
// y a la vez dentro del que atiende a Nuria:
Material material = catalogo.buscarPorIsbn(isbn);      // seguro: ConcurrentHashMap
catalogo.registrarConsulta();                          // seguro: LongAdder

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.dominio.Material;
import com.nexussoftware.bibliotech.servicio.CatalogoConcurrente;
import com.nexussoftware.bibliotech.servicio.RegistroPrestamosSeguro;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Servidor del protocolo BTCP/1 de BiblioTech.
 *
 * - Un hilo aceptador que solo acepta y delega.
 * - Un pool ACOTADO de hilos que atienden las conversaciones (modulo 8).
 * - Estado compartido en CatalogoConcurrente (ConcurrentHashMap): ya era seguro.
 * - Validacion estricta de todo lo que llega por la red.
 * - setSoTimeout por conexion para expulsar clientes inactivos.
 * - Apagado ordenado en dos fases.
 */
public class ServidorCatalogo implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(ServidorCatalogo.class.getName());

    // --- Limites defensivos: todos los valores que vienen de la red se acotan ---
    /** Ninguna peticion BTCP/1 legitima pasa de esto. Evita el agotamiento de memoria. */
    private static final int MAXIMO_LONGITUD_LINEA = 512;
    /** Peticiones seguidas por conexion: evita que un cliente monopolice un hilo. */
    private static final int MAXIMO_PETICIONES = 1_000;
    /** Un ISBN de BiblioTech tiene esta forma y nada mas. */
    private static final int MAXIMO_ISBN = 20;
    private static final int MAXIMO_EMPLEADO = 60;

    private final int puerto;
    private final String direccionEscucha;
    private final int hilos;
    private final int colaEspera;
    private final int limiteInactividadMs;

    private final CatalogoConcurrente catalogo;
    private final RegistroPrestamosSeguro prestamos;

    private ServerSocket servidor;
    private ThreadPoolExecutor pool;

    /** volatile: la escribe el hilo que para, la lee el hilo aceptador (08-04). */
    private volatile boolean ejecutando = false;

    private final AtomicInteger conexionesActivas = new AtomicInteger();
    private final AtomicLong conexionesTotales = new AtomicLong();
    private final AtomicLong peticionesAtendidas = new AtomicLong();
    private final AtomicLong conexionesRechazadas = new AtomicLong();

    public ServidorCatalogo(int puerto, String direccionEscucha, int hilos,
                            int colaEspera, int limiteInactividadMs,
                            CatalogoConcurrente catalogo,
                            RegistroPrestamosSeguro prestamos) {
        this.puerto = puerto;
        this.direccionEscucha = direccionEscucha;
        this.hilos = hilos;
        this.colaEspera = colaEspera;
        this.limiteInactividadMs = limiteInactividadMs;
        this.catalogo = catalogo;
        this.prestamos = prestamos;
    }

    // =================================================================
    // Arranque
    // =================================================================

    /** Prepara el socket y el pool. No bloquea. */
    public void arrancar() throws IOException {
        // Patron de tres pasos: crear sin atar, configurar, atar.
        // setReuseAddress DEBE ir antes del bind, o no sirve de nada.
        servidor = new ServerSocket();
        servidor.setReuseAddress(true);
        servidor.bind(new InetSocketAddress(direccionEscucha, puerto), colaEspera);

        ThreadFactory fabrica = new ThreadFactory() {
            private final AtomicInteger n = new AtomicInteger(1);

            @Override
            public Thread newThread(Runnable r) {
                // Nombres legibles: en un volcado de hilos y en cada linea
                // de log sabras exactamente quien hace que (08-02).
                Thread h = new Thread(r, "bibliotech-cliente-" + n.getAndIncrement());
                h.setDaemon(false);
                return h;
            }
        };

        pool = new ThreadPoolExecutor(
                hilos, hilos,
                60L, TimeUnit.SECONDS,
                // Cola ACOTADA: newFixedThreadPool usa una sin limite y eso
                // convierte una saturacion en un OutOfMemoryError.
                new LinkedBlockingQueue<>(colaEspera),
                fabrica,
                // Rechazar rapido y decirselo al cliente es mejor que
                // aceptar y no responder.
                new ThreadPoolExecutor.AbortPolicy());

        ejecutando = true;
        LOG.info(() -> "ServidorCatalogo BTCP/1 escuchando en "
                + direccionEscucha + ":" + puerto
                + " (pool=" + hilos + ", cola=" + colaEspera + ")");
    }

    /** Bucle de aceptacion. Bloquea hasta que se llama a close(). */
    public void ejecutar() {
        while (ejecutando) {
            Socket conexion = null;
            try {
                conexion = servidor.accept();       // BLOQUEA aqui

                // Tiempo limite de INACTIVIDAD por conexion. Es lo que expulsa
                // a los clientes que conectan y se callan, y ademas lo que
                // permite que shutdownNow() consiga parar los hilos.
                conexion.setSoTimeout(limiteInactividadMs);
                conexion.setTcpNoDelay(true);       // protocolo interactivo: sin Nagle

                final Socket aceptada = conexion;
                conexionesTotales.incrementAndGet();

                // El hilo aceptador NO atiende: delega y vuelve al accept().
                pool.execute(() -> atenderConexion(aceptada));

            } catch (RejectedExecutionException e) {
                // Pool y cola llenos: el servidor esta saturado.
                conexionesRechazadas.incrementAndGet();
                LOG.warning("Servidor saturado; conexion rechazada");
                rechazar(conexion, "503 SERVIDOR SATURADO");

            } catch (SocketException e) {
                // Nuestro propio close() O un fallo real. La bandera decide.
                if (!ejecutando) {
                    LOG.info("Bucle de aceptacion terminado ordenadamente");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallo inesperado en accept()", e);
                return;

            } catch (IOException e) {
                // Un fallo aceptando UNA conexion no tumba el servidor.
                LOG.log(Level.WARNING, "Error aceptando una conexion", e);
                cerrarSilenciosamente(conexion);
            }
        }
    }

    // =================================================================
    // Atencion de una conexion (se ejecuta en un hilo del pool)
    // =================================================================

    private void atenderConexion(Socket conexion) {
        String cliente = String.valueOf(conexion.getRemoteSocketAddress());
        int activas = conexionesActivas.incrementAndGet();
        LOG.info(() -> "[" + cliente + "] conectado (" + activas + " activas)");

        // try-with-resources: el socket se cierra pase lo que pase.
        try (conexion) {
            BufferedReader lector = new BufferedReader(
                    new InputStreamReader(conexion.getInputStream(),
                            StandardCharsets.UTF_8));
            PrintWriter escritor = new PrintWriter(
                    new BufferedWriter(
                            new OutputStreamWriter(conexion.getOutputStream(),
                                    StandardCharsets.UTF_8)),
                    false);     // sin autoFlush: vaciamos a mano tras cada respuesta

            // El servidor habla primero, como especifica el protocolo.
            responder(escritor, "200 BIBLIOTECH BTCP/1");

            int peticiones = 0;
            while (!Thread.currentThread().isInterrupted()) {

                if (peticiones++ >= MAXIMO_PETICIONES) {
                    // Un cliente no puede quedarse con un hilo indefinidamente.
                    responder(escritor, "421 DEMASIADAS PETICIONES");
                    LOG.warning("[" + cliente + "] supero el limite de peticiones");
                    return;
                }

                String linea = leerLineaAcotada(lector);
                if (linea == null) {
                    LOG.info(() -> "[" + cliente + "] cerro la conexion");
                    return;
                }

                peticionesAtendidas.incrementAndGet();
                boolean seguir = procesar(linea, escritor, cliente);
                if (!seguir) {
                    return;
                }
            }

        } catch (SocketTimeoutException e) {
            // El cliente conecto y se callo. Se le expulsa: el hilo vuelve al pool.
            LOG.info(() -> "[" + cliente + "] expulsado por inactividad ("
                    + limiteInactividadMs + " ms)");

        } catch (LineaDemasiadoLargaException e) {
            LOG.warning("[" + cliente + "] envio una linea de mas de "
                    + MAXIMO_LONGITUD_LINEA + " caracteres; conexion cortada");

        } catch (SocketException e) {
            // "Connection reset": el cliente se cayo. Es normal, no es un error grave.
            LOG.info(() -> "[" + cliente + "] conexion perdida: " + e.getMessage());

        } catch (IOException e) {
            LOG.log(Level.WARNING, "[" + cliente + "] fallo de E/S", e);

        } catch (RuntimeException e) {
            // Un fallo de programacion en el manejo de UN cliente no puede
            // matar el hilo del pool ni afectar a los demas. Este catch
            // es la frontera de errores de 06-07 aplicada a cada conexion.
            LOG.log(Level.SEVERE, "[" + cliente + "] fallo inesperado", e);

        } finally {
            int quedan = conexionesActivas.decrementAndGet();
            LOG.info(() -> "[" + cliente + "] desconectado (" + quedan + " activas)");
        }
    }

    // =================================================================
    // Procesado de una peticion
    // =================================================================

    /** Devuelve false si hay que cerrar la conexion tras esta peticion. */
    private boolean procesar(String linea, PrintWriter escritor, String cliente) {
        // Se separa el comando del resto por el PRIMER espacio: el nombre
        // de empleado puede llevar espacios y no queremos partirlo.
        String comando;
        String resto;
        int espacio = linea.indexOf(' ');
        if (espacio < 0) {
            comando = linea;
            resto = "";
        } else {
            comando = linea.substring(0, espacio);
            resto = linea.substring(espacio + 1).strip();
        }

        // Los comandos se comparan en mayusculas para ser tolerantes,
        // pero el protocolo los documenta en mayusculas.
        switch (comando.toUpperCase()) {

            case "CONSULTA" -> {
                if (!isbnValido(resto)) {
                    responder(escritor, "400 PETICION INVALIDA isbn no valido");
                    return true;
                }
                Material material = catalogo.buscarPorIsbn(resto);
                if (material == null) {
                    responder(escritor, "404 NO ENCONTRADO " + resto);
                } else {
                    responder(escritor, "200 OK " + formatear(material));
                }
                return true;
            }

            case "LISTA" -> {
                if (!resto.isEmpty()) {
                    responder(escritor, "400 PETICION INVALIDA LISTA no admite argumentos");
                    return true;
                }
                List<Material> materiales = catalogo.todos();
                responder(escritor, "201 LISTA " + materiales.size());
                for (Material m : materiales) {
                    responder(escritor, formatear(m));
                }
                responder(escritor, ".");
                return true;
            }

            case "PRESTAR" -> {
                int sep = resto.indexOf(' ');
                if (sep < 0) {
                    responder(escritor, "400 PETICION INVALIDA faltan argumentos");
                    return true;
                }
                String isbn = resto.substring(0, sep);
                String empleado = resto.substring(sep + 1).strip();

                if (!isbnValido(isbn) || !empleadoValido(empleado)) {
                    responder(escritor, "400 PETICION INVALIDA argumentos no validos");
                    return true;
                }
                if (catalogo.buscarPorIsbn(isbn) == null) {
                    responder(escritor, "404 NO ENCONTRADO " + isbn);
                    return true;
                }

                // OPERACION COMPUESTA ATOMICA: comprobar disponibilidad y prestar
                // en una sola llamada al servicio. Encadenar dos operaciones
                // seguras NO da una operacion segura (08-06).
                boolean prestado = prestamos.prestarSiDisponible(isbn, empleado);
                if (prestado) {
                    LOG.info(() -> "[" + cliente + "] prestamo de " + isbn
                            + " a " + empleado);
                    responder(escritor, "200 OK prestamo registrado");
                } else {
                    responder(escritor, "409 NO DISPONIBLE " + isbn);
                }
                return true;
            }

            case "SALIR" -> {
                responder(escritor, "221 ADIOS");
                return false;       // cerrar la conexion
            }

            default -> {
                // NO devolvemos el comando tal cual al cliente sin sanear:
                // podria contener secuencias de escape de terminal.
                responder(escritor, "400 PETICION INVALIDA comando desconocido: "
                        + sanear(comando));
                return true;
            }
        }
    }

    private String formatear(Material m) {
        return m.getIsbn() + "|" + m.getTitulo() + "|"
                + m.getTipo() + "|" + m.estaDisponible();
    }

    // =================================================================
    // E/S de bajo nivel del protocolo
    // =================================================================

    /** Escribe una linea del protocolo y VACIA. Sin flush, el cliente espera eternamente. */
    private void responder(PrintWriter escritor, String linea) {
        escritor.print(linea + "\n");       // \n explicito: el protocolo lo exige
        escritor.flush();                   // OBLIGATORIO
        if (escritor.checkError()) {
            // PrintWriter se traga las IOException; checkError es la unica pista.
            LOG.fine("Fallo al escribir la respuesta; el cliente probablemente cerro");
        }
    }

    /** Excepcion interna para una linea que excede el limite. */
    private static class LineaDemasiadoLargaException extends IOException {
        LineaDemasiadoLargaException(String m) {
            super(m);
        }
    }

    /**
     * Lee una linea ACOTADA. BufferedReader.readLine() no tiene limite:
     * un cliente malicioso puede enviar 100 MB sin un solo salto de linea
     * y agotar la memoria del servidor. Esta es una defensa obligatoria
     * en cualquier servidor expuesto.
     */
    private String leerLineaAcotada(BufferedReader lector) throws IOException {
        StringBuilder sb = new StringBuilder();
        int c;
        while ((c = lector.read()) != -1) {
            if (c == '\n') {
                // Aceptamos tambien \r\n quitando el retorno de carro final.
                int fin = sb.length();
                if (fin > 0 && sb.charAt(fin - 1) == '\r') {
                    sb.setLength(fin - 1);
                }
                return sb.toString();
            }
            if (sb.length() >= MAXIMO_LONGITUD_LINEA) {
                throw new LineaDemasiadoLargaException(
                        "Linea de mas de " + MAXIMO_LONGITUD_LINEA + " caracteres");
            }
            sb.append((char) c);
        }
        // Fin de flujo. Si habia algo a medias, se descarta: no es una linea valida.
        return null;
    }

    // =================================================================
    // Validacion: NUNCA confiar en lo que llega por la red
    // =================================================================

    private boolean isbnValido(String isbn) {
        if (isbn == null || isbn.isBlank() || isbn.length() > MAXIMO_ISBN) {
            return false;
        }
        // Lista BLANCA de caracteres: solo digitos y guiones. Todo lo demas fuera.
        // Una lista blanca es siempre mas segura que una lista negra.
        for (int i = 0; i < isbn.length(); i++) {
            char c = isbn.charAt(i);
            if (!Character.isDigit(c) && c != '-') {
                return false;
            }
        }
        return true;
    }

    private boolean empleadoValido(String empleado) {
        if (empleado == null || empleado.isBlank() || empleado.length() > MAXIMO_EMPLEADO) {
            return false;
        }
        for (int i = 0; i < empleado.length(); i++) {
            char c = empleado.charAt(i);
            // Letras, digitos, espacios, guiones bajos y guiones. Nada de
            // caracteres de control, que romperian el protocolo o el log.
            if (!Character.isLetterOrDigit(c) && c != ' ' && c != '_' && c != '-') {
                return false;
            }
        }
        return true;
    }

    /**
     * Sanea un texto que viene de la red antes de devolverlo o registrarlo.
     * Sin esto, un cliente puede inyectar \n (una respuesta falsa en el
     * protocolo) o secuencias de escape ANSI (que manipulan el terminal
     * de quien lea el log). Es INYECCION DE LOG, un problema real.
     */
    private String sanear(String texto) {
        StringBuilder sb = new StringBuilder();
        int limite = Math.min(texto.length(), 40);
        for (int i = 0; i < limite; i++) {
            char c = texto.charAt(i);
            sb.append(Character.isISOControl(c) ? '?' : c);
        }
        return sb.toString();
    }

    // =================================================================
    // Apagado ordenado
    // =================================================================

    @Override
    public void close() {
        if (!ejecutando) {
            return;
        }
        LOG.info("Apagando ServidorCatalogo...");

        // 1. Bandera ANTES del cierre: distingue el apagado limpio de un fallo.
        ejecutando = false;

        // 2. Cerrar el ServerSocket es lo UNICO que desbloquea accept().
        //    Thread.interrupt() no lo consigue.
        cerrarSilenciosamente(servidor);

        // 3. Apagado en dos fases del pool (08-05).
        if (pool != null) {
            pool.shutdown();        // no admite tareas nuevas; las actuales siguen
            try {
                if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
                    LOG.warning("Conversaciones activas tras 10 s: se fuerza el cierre");
                    pool.shutdownNow();     // interrumpe los hilos
                    if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                        LOG.severe("Quedan hilos sin terminar");
                    }
                }
            } catch (InterruptedException e) {
                pool.shutdownNow();
                Thread.currentThread().interrupt();   // 08-02: restaurar la bandera
            }
        }

        LOG.info(() -> String.format(
                "ServidorCatalogo detenido. Conexiones: %d totales, %d rechazadas. "
                + "Peticiones atendidas: %d",
                conexionesTotales.get(), conexionesRechazadas.get(),
                peticionesAtendidas.get()));
    }

    private void rechazar(Socket conexion, String mensaje) {
        if (conexion == null) {
            return;
        }
        // Cortesia: decirle al cliente por que se le cierra, en lugar de
        // cortarle sin explicacion. Cuesta dos lineas y ahorra soporte.
        try (conexion) {
            PrintWriter escritor = new PrintWriter(
                    new OutputStreamWriter(conexion.getOutputStream(),
                            StandardCharsets.UTF_8));
            escritor.print(mensaje + "\n");
            escritor.flush();
        } catch (IOException e) {
            LOG.fine("No se pudo notificar el rechazo: " + e.getMessage());
        }
    }

    private void cerrarSilenciosamente(java.io.Closeable recurso) {
        if (recurso != null) {
            try {
                recurso.close();
            } catch (IOException ignorada) {
                // Cerrando ya no hay nada que salvar.
            }
        }
    }

    // --- Metricas para el menu de BiblioTech ---

    public int conexionesActivas() {
        return conexionesActivas.get();
    }

    public long conexionesTotales() {
        return conexionesTotales.get();
    }

    public long peticionesAtendidas() {
        return peticionesAtendidas.get();
    }
}

package com.nexussoftware.bibliotech.presentacion;

import com.nexussoftware.bibliotech.persistencia.Configuracion;
import com.nexussoftware.bibliotech.red.ServidorCatalogo;
import com.nexussoftware.bibliotech.servicio.CatalogoConcurrente;
import com.nexussoftware.bibliotech.servicio.RegistroPrestamosSeguro;
import com.nexussoftware.bibliotech.infra.ConfiguracionLog;

import java.io.IOException;
import java.util.logging.Logger;

/** Arranque del servidor de catalogo de BiblioTech. */
public class ServidorBiblioTechApp {

    private static final Logger LOG = Logger.getLogger(ServidorBiblioTechApp.class.getName());

    public static void main(String[] args) throws IOException {
        ConfiguracionLog.inicializar();     // el logger del modulo 6, ya configurado

        // La configuracion sale de bibliotech.properties (07-07).
        Configuracion config = Configuracion.cargar();
        int puerto = config.entero("red.puerto", 9090);
        String escucha = config.texto("red.escucha", "0.0.0.0");
        int hilos = config.entero("red.hilos", 16);
        int cola = config.entero("red.cola", 100);
        int inactividad = config.entero("red.inactividad.ms", 60_000);

        CatalogoConcurrente catalogo = CatalogoConcurrente.cargarDesdeFichero();
        RegistroPrestamosSeguro prestamos = new RegistroPrestamosSeguro(catalogo);

        ServidorCatalogo servidor = new ServidorCatalogo(
                puerto, escucha, hilos, cola, inactividad, catalogo, prestamos);
        servidor.arrancar();

        // Shutdown hook: se ejecuta con Ctrl+C o con SIGTERM (que es lo que
        // envia Docker, systemd o Kubernetes al parar un contenedor).
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            LOG.info("Senal de apagado recibida");
            servidor.close();
        }, "bibliotech-apagado"));

        // Bloquea aqui hasta que el ServerSocket se cierre.
        servidor.ejecutar();

        LOG.info("Servidor terminado");
    }
}

javac -d clases $(find src -name "*.java")
java -cp clases com.nexussoftware.bibliotech.presentacion.ServidorBiblioTechApp

INFO: ServidorCatalogo BTCP/1 escuchando en 0.0.0.0:9090 (pool=16, cola=100)

telnet localhost 9090

Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
200 BIBLIOTECH BTCP/1
CONSULTA 978-0000000001                                  <-- TECLEAS
200 OK 978-0000000001|Java Efectivo|LIBRO|true
CONSULTA 999                                             <-- TECLEAS
404 NO ENCONTRADO 999
CONSULTA ../../etc/passwd                                <-- TECLEAS
400 PETICION INVALIDA isbn no valido
LISTA                                                    <-- TECLEAS
201 LISTA 3
978-0000000001|Java Efectivo|LIBRO|true
978-0000000002|Patrones de Diseno|LIBRO|false
978-0000000003|Refactorizacion|LIBRO|true
.
PRESTAR 978-0000000003 Nuria Vidal                       <-- TECLEAS
200 OK prestamo registrado
PRESTAR 978-0000000003 Diego Alonso                      <-- TECLEAS
409 NO DISPONIBLE 978-0000000003
PIDEME UN CAFE                                           <-- TECLEAS
400 PETICION INVALIDA comando desconocido: PIDEME
SALIR                                                    <-- TECLEAS
221 ADIOS
Connection closed by foreign host.

printf 'LISTA\nSALIR\n' | nc localhost 9090

200 BIBLIOTECH BTCP/1
201 LISTA 3
978-0000000001|Java Efectivo|LIBRO|true
978-0000000002|Patrones de Diseno|LIBRO|false
978-0000000003|Refactorizacion|LIBRO|true
.
221 ADIOS

INFO: [/127.0.0.1:52440] conectado (1 activas)
INFO: [/127.0.0.1:52441] conectado (2 activas)
INFO: [/127.0.0.1:52441] prestamo de 978-0000000003 a Nuria Vidal
INFO: [/127.0.0.1:52442] conectado (3 activas)
INFO: [/127.0.0.1:52442] cerro la conexion
INFO: [/127.0.0.1:52442] desconectado (2 activas)
INFO: [/127.0.0.1:52441] desconectado (1 activas)
INFO: [/127.0.0.1:52440] desconectado (0 activas)

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    LOG.info("Senal de apagado recibida");
    servidor.close();
}, "bibliotech-apagado"));

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    LOG.info("Apagando BiblioTech...");
    servidor.close();                 // 1. dejar de aceptar y cerrar conversaciones
    ApagadoOrdenado.detenerServicios(); // 2. pools de avisos, mantenimiento, reservas
    AlmacenPrestamos.volcar();         // 3. persistir lo pendiente (modulo 7)
    LOG.info("BiblioTech detenido correctamente");
}, "bibliotech-apagado"));

// E/S no bloqueante: UN hilo atiende miles de conexiones.
Selector selector = Selector.open();
ServerSocketChannel canal = ServerSocketChannel.open();
canal.bind(new InetSocketAddress(9090));
canal.configureBlocking(false);                          // clave: no bloqueante
canal.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();          // bloquea hasta que ALGUN canal tiene actividad
    for (SelectionKey clave : selector.selectedKeys()) {
        if (clave.isAcceptable()) { /* aceptar */ }
        if (clave.isReadable())   { /* leer lo que haya, sin bloquear */ }
    }
}

// Java 21+: un hilo VIRTUAL por conexion. Sin pool, sin limite practico.
try (ExecutorService ejecutor = Executors.newVirtualThreadPerTaskExecutor()) {
    while (ejecutando) {
        Socket conexion = servidor.accept();
        ejecutor.submit(() -> atenderConexion(conexion));
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Servidor de estadisticas de BiblioTech.
 *
 * SEGURIDAD: escucha SOLO en 127.0.0.1. Las metricas de un servicio revelan
 * informacion util para un atacante (carga, saturacion, memoria, ventanas de
 * baja actividad) y suelen ser el primer sitio donde se filtra algo sin querer.
 * Exponerlas a la red seria un fallo de diseno; si hay que consultarlas desde
 * fuera, se hace por un tunel SSH o tras un proxy autenticado (12-07).
 */
public class ServidorEstadisticas implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(ServidorEstadisticas.class.getName());

    private final int puerto;
    private final ServidorCatalogo principal;
    private final ThreadPoolExecutor poolPrincipal;
    private final ExecutorService pool;
    private final long instanteArranque = System.currentTimeMillis();

    private ServerSocket servidor;
    private volatile boolean ejecutando = false;

    public ServidorEstadisticas(int puerto, ServidorCatalogo principal,
                                ThreadPoolExecutor poolPrincipal, ExecutorService pool) {
        this.puerto = puerto;
        this.principal = principal;
        this.poolPrincipal = poolPrincipal;
        this.pool = pool;       // se comparte el pool: no hacen falta hilos propios
    }

    public void arrancar() throws IOException {
        servidor = new ServerSocket();
        servidor.setReuseAddress(true);
        // El tercer argumento del bind ATA la escucha al bucle invertido:
        // ni siquiera un fallo de cortafuegos expondria este puerto.
        servidor.bind(new InetSocketAddress(
                InetAddress.getLoopbackAddress(), puerto), 10);
        ejecutando = true;

        // Hilo aceptador propio, porque accept() bloquea.
        Thread aceptador = new Thread(this::ejecutar, "bibliotech-stats-aceptador");
        aceptador.setDaemon(true);      // este si puede ser daemon: no tiene estado
        aceptador.start();

        LOG.info(() -> "Servidor de estadisticas en 127.0.0.1:" + puerto);
    }

    private void ejecutar() {
        while (ejecutando) {
            try {
                Socket conexion = servidor.accept();
                conexion.setSoTimeout(5_000);
                // Se delega al pool compartido: no atendemos en el aceptador.
                pool.execute(() -> servirInforme(conexion));

            } catch (SocketException e) {
                if (!ejecutando) {
                    LOG.info("Servidor de estadisticas detenido");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallo en accept() de estadisticas", e);
                return;

            } catch (IOException e) {
                LOG.log(Level.WARNING, "Error aceptando conexion de estadisticas", e);
            }
        }
    }

    /**
     * Este servicio no tiene protocolo: al conectar, escribe y cierra.
     * Es lo que permite consultarlo con un simple "nc localhost 9092".
     */
    private void servirInforme(Socket conexion) {
        try (conexion) {
            BufferedWriter escritor = new BufferedWriter(
                    new OutputStreamWriter(conexion.getOutputStream(),
                            StandardCharsets.UTF_8));
            escritor.write(construirInforme());
            escritor.flush();       // el flush de siempre
        } catch (IOException e) {
            LOG.fine("Fallo sirviendo el informe: " + e.getMessage());
        }
    }

    private String construirInforme() {
        Runtime rt = Runtime.getRuntime();
        long usada = (rt.totalMemory() - rt.freeMemory()) / (1024 * 1024);
        long maxima = rt.maxMemory() / (1024 * 1024);
        long segundos = (System.currentTimeMillis() - instanteArranque) / 1000;

        StringBuilder sb = new StringBuilder();
        sb.append("=== BIBLIOTECH - ESTADO DEL SERVIDOR ===\n");
        sb.append(String.format("%-28s %s%n", "En marcha desde hace",
                formatearDuracion(segundos)));
        sb.append('\n');
        sb.append("--- CONEXIONES ---\n");
        sb.append(String.format("%-28s %d%n", "Activas", principal.conexionesActivas()));
        sb.append(String.format("%-28s %d%n", "Totales", principal.conexionesTotales()));
        sb.append(String.format("%-28s %d%n", "Peticiones atendidas",
                principal.peticionesAtendidas()));
        sb.append('\n');
        sb.append("--- POOL DE HILOS ---\n");
        sb.append(String.format("%-28s %d%n", "Hilos activos",
                poolPrincipal.getActiveCount()));
        sb.append(String.format("%-28s %d%n", "Tamano del pool",
                poolPrincipal.getPoolSize()));
        sb.append(String.format("%-28s %d%n", "Tareas en cola",
                poolPrincipal.getQueue().size()));
        sb.append(String.format("%-28s %d%n", "Tareas completadas",
                poolPrincipal.getCompletedTaskCount()));
        sb.append('\n');
        sb.append("--- MEMORIA ---\n");
        sb.append(String.format("%-28s %d MB de %d MB (%.1f%%)%n",
                "Usada", usada, maxima, 100.0 * usada / maxima));
        sb.append(String.format("%-28s %d%n", "Nucleos disponibles",
                rt.availableProcessors()));
        return sb.toString();
    }

    private String formatearDuracion(long segundos) {
        // Sin java.time (eso es 10-05): aritmetica simple sobre enteros.
        long h = segundos / 3600;
        long m = (segundos % 3600) / 60;
        long s = segundos % 60;
        return String.format("%dh %02dm %02ds", h, m, s);
    }

    @Override
    public void close() {
        ejecutando = false;
        try {
            if (servidor != null) {
                servidor.close();       // desbloquea el accept()
            }
        } catch (IOException ignorada) {
            // Cerrando ya no hay nada que salvar.
        }
    }
}

nc localhost 9092

=== BIBLIOTECH - ESTADO DEL SERVIDOR ===
En marcha desde hace         0h 04m 17s

--- CONEXIONES ---
Activas                      2
Totales                      47
Peticiones atendidas         183

--- POOL DE HILOS ---
Hilos activos                2
Tamano del pool              16
Tareas en cola               0
Tareas completadas           45

--- MEMORIA ---
Usada                        28 MB de 4096 MB (0,7%)
Nucleos disponibles          8

package com.nexussoftware.bibliotech.red;

import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Logger;

/**
 * Limitador de conexiones simultaneas por direccion IP.
 *
 * Evita que un solo equipo (por error o a proposito) ocupe todo el pool
 * de hilos del servidor y deje sin servicio a los demas puestos de trabajo.
 */
public class LimitadorPorIp {

    private static final Logger LOG = Logger.getLogger(LimitadorPorIp.class.getName());

    private final int maximoPorIp;
    private final boolean eximirBucleInvertido;

    /** Cuenta conexiones activas por IP. Concurrente: lo tocan todos los hilos. */
    private final ConcurrentHashMap<String, AtomicInteger> porIp = new ConcurrentHashMap<>();
    private final AtomicLong rechazadasPorLimite = new AtomicLong();

    public LimitadorPorIp(int maximoPorIp, boolean eximirBucleInvertido) {
        this.maximoPorIp = maximoPorIp;
        this.eximirBucleInvertido = eximirBucleInvertido;
    }

    /**
     * Intenta reservar una plaza para esta IP.
     * Devuelve true si se admite; false si se ha alcanzado el limite.
     */
    public boolean admitir(Socket conexion) {
        String ip = ipDe(conexion);

        if (eximirBucleInvertido && esBucleInvertido(ip)) {
            // Sin la exencion, probar el servidor con varios telnet desde
            // la propia maquina seria imposible.
            return true;
        }

        // computeIfAbsent es atomico: si dos hilos llegan a la vez con la
        // misma IP, solo uno crea el AtomicInteger y ambos usan el mismo.
        AtomicInteger contador = porIp.computeIfAbsent(ip, clave -> new AtomicInteger());

        // Bucle de comparar-e-intercambiar: la forma atomica de decir
        // "incrementa SOLO SI el valor actual es menor que el maximo".
        // Un "if (get() < max) incrementAndGet()" tendria una carrera:
        // dos hilos podrian pasar el if a la vez y superar el limite.
        while (true) {
            int actual = contador.get();
            if (actual >= maximoPorIp) {
                rechazadasPorLimite.incrementAndGet();
                LOG.warning("Limite de " + maximoPorIp
                        + " conexiones alcanzado para " + ip);
                return false;
            }
            if (contador.compareAndSet(actual, actual + 1)) {
                return true;    // reserva conseguida
            }
            // compareAndSet fallo: otro hilo cambio el valor entremedias.
            // Se reintenta con el valor nuevo. Esto es 08-06.
        }
    }

    /**
     * Libera la plaza. DEBE llamarse siempre, desde un finally.
     */
    public void liberar(Socket conexion) {
        String ip = ipDe(conexion);

        if (eximirBucleInvertido && esBucleInvertido(ip)) {
            return;     // no se reservo, no se libera
        }

        // computeIfPresent hace ATOMICAMENTE el par "decrementar y, si
        // llega a cero, eliminar la entrada". Devolver null desde la
        // funcion elimina la clave del mapa.
        //
        // Hacerlo en dos pasos tendria una carrera clasica:
        //     if (contador.decrementAndGet() == 0) porIp.remove(ip);
        // Entre el decremento y el remove, otro hilo puede incrementar
        // ese mismo contador a 1 (una conexion nueva de la misma IP), y
        // el remove eliminaria un contador que ya vale 1. La conexion
        // nueva quedaria contabilizada en un objeto huerfano y el limite
        // dejaria de aplicarse a esa IP.
        porIp.computeIfPresent(ip, (clave, contador) -> {
            int quedan = contador.decrementAndGet();
            return quedan <= 0 ? null : contador;    // null elimina la entrada
        });
    }

    private String ipDe(Socket conexion) {
        return conexion.getInetAddress().getHostAddress();
    }

    private boolean esBucleInvertido(String ip) {
        return ip.equals("127.0.0.1") || ip.equals("0:0:0:0:0:0:0:1") || ip.equals("::1");
    }

    public long rechazadasPorLimite() {
        return rechazadasPorLimite.get();
    }

    public int ipsConectadas() {
        return porIp.size();
    }
}

// En ejecutar(), tras aceptar:
Socket aceptada = servidor.accept();
aceptada.setSoTimeout(limiteInactividadMs);
aceptada.setTcpNoDelay(true);

if (!limitador.admitir(aceptada)) {
    rechazar(aceptada, "429 DEMASIADAS CONEXIONES");
    continue;       // NO se llego a delegar al pool: no hay nada que liberar
}

try {
    pool.execute(() -> atenderConexion(aceptada));
} catch (RejectedExecutionException e) {
    // OJO: la plaza YA estaba reservada. Si no se libera aqui,
    // se fuga una plaza en cada rechazo del pool y la IP acaba
    // bloqueada para siempre.
    limitador.liberar(aceptada);
    rechazar(aceptada, "503 SERVIDOR SATURADO");
}

} finally {
    limitador.liberar(conexion);        // SIEMPRE, pase lo que pase
    int quedan = conexionesActivas.decrementAndGet();
    LOG.info(() -> "[" + cliente + "] desconectado (" + quedan + " activas)");
}

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.excepcion.BiblioTechException;

import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Prueba de carga del ServidorCatalogo usando el ClienteCatalogo de 09-02.
 * Mide latencias, tasa de error y peticiones por segundo.
 */
public class PruebaCarga {

    private static final String[] ISBNS = {
            "978-0000000001",
            "978-0000000002",
            "978-0000000003",
            "000-0000000000"    // inexistente a proposito: debe dar 404, no error
    };

    private final String host;
    private final int puerto;

    private final AtomicInteger correctas = new AtomicInteger();
    private final AtomicInteger errores = new AtomicInteger();
    private final AtomicInteger conexionesFallidas = new AtomicInteger();
    private final AtomicLong indiceLatencias = new AtomicLong();

    /** Latencias en microsegundos. Array preasignado: sin sincronizacion al escribir. */
    private long[] latencias;

    public PruebaCarga(String host, int puerto) {
        this.host = host;
        this.puerto = puerto;
    }

    public void ejecutar(int clientes, int peticionesPorCliente) throws InterruptedException {
        latencias = new long[clientes * peticionesPorCliente];

        // Pool para los clientes de la prueba, con hilos nombrados.
        ExecutorService pool = Executors.newFixedThreadPool(clientes, r -> {
            Thread h = new Thread(r);
            h.setName("carga-" + h.getId());
            return h;
        });

        // Dos latches: uno para que TODOS arranquen a la vez (carga real,
        // no una rampa), y otro para esperar a que TODOS terminen (08-05).
        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch llegada = new CountDownLatch(clientes);

        for (int i = 0; i < clientes; i++) {
            final int id = i;
            pool.execute(() -> {
                try {
                    salida.await();     // todos esperan aqui al pistoletazo
                    trabajar(id, peticionesPorCliente);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    llegada.countDown();
                }
            });
        }

        System.out.printf("Lanzando %d clientes x %d peticiones = %d peticiones%n%n",
                clientes, peticionesPorCliente, clientes * peticionesPorCliente);

        long t0 = System.nanoTime();
        salida.countDown();                     // ¡ya!
        llegada.await();                        // esperamos a todos
        long duracionNs = System.nanoTime() - t0;

        // Apagado en dos fases del pool de la prueba (08-05).
        pool.shutdown();
        if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
            pool.shutdownNow();
        }

        informe(duracionNs);
    }

    private void trabajar(int id, int peticiones) {
        // Cada cliente abre su propia conexion: ClienteCatalogo NO es
        // seguro para varios hilos, y ademas asi medimos conexiones reales.
        try (ClienteCatalogo cliente = new ClienteCatalogo(host, puerto)) {
            cliente.conectar();

            for (int i = 0; i < peticiones; i++) {
                String isbn = ISBNS[(id + i) % ISBNS.length];

                long t0 = System.nanoTime();
                try {
                    cliente.consultar(isbn);    // null (404) tambien es exito
                    long us = (System.nanoTime() - t0) / 1000;

                    // Cada hilo escribe en su propia posicion del array:
                    // sin colisiones, sin sincronizacion. El indice se
                    // reparte con un contador atomico.
                    int pos = (int) indiceLatencias.getAndIncrement();
                    if (pos < latencias.length) {
                        latencias[pos] = us;
                    }
                    correctas.incrementAndGet();

                } catch (BiblioTechException e) {
                    errores.incrementAndGet();
                }
            }
        } catch (BiblioTechException e) {
            // No se pudo ni conectar: se cuenta aparte, porque significa
            // otra cosa (saturacion) que un error en una peticion.
            conexionesFallidas.incrementAndGet();
        }
    }

    private void informe(long duracionNs) {
        int hechas = (int) Math.min(indiceLatencias.get(), latencias.length);
        if (hechas == 0) {
            System.out.println("No se completo ninguna peticion.");
            System.out.println("Conexiones fallidas: " + conexionesFallidas.get());
            return;
        }

        long[] ordenadas = Arrays.copyOf(latencias, hechas);
        Arrays.sort(ordenadas);     // 05-09: ordenacion para los percentiles

        long suma = 0;
        for (long v : ordenadas) {
            suma += v;
        }

        double segundos = duracionNs / 1_000_000_000.0;
        double porSegundo = correctas.get() / segundos;

        System.out.println("=== RESULTADO DE LA PRUEBA DE CARGA ===");
        System.out.printf("%-26s %.2f s%n", "Duracion total", segundos);
        System.out.printf("%-26s %d%n", "Peticiones correctas", correctas.get());
        System.out.printf("%-26s %d%n", "Peticiones con error", errores.get());
        System.out.printf("%-26s %d%n", "Conexiones fallidas", conexionesFallidas.get());
        System.out.printf("%-26s %.0f%n", "Peticiones por segundo", porSegundo);
        System.out.println();
        System.out.println("--- LATENCIAS (ms) ---");
        System.out.printf("%-26s %.3f%n", "Minima", ordenadas[0] / 1000.0);
        System.out.printf("%-26s %.3f%n", "Media", (suma / (double) hechas) / 1000.0);
        System.out.printf("%-26s %.3f%n", "Mediana (p50)", percentil(ordenadas, 50) / 1000.0);
        System.out.printf("%-26s %.3f%n", "p95", percentil(ordenadas, 95) / 1000.0);
        System.out.printf("%-26s %.3f%n", "p99", percentil(ordenadas, 99) / 1000.0);
        System.out.printf("%-26s %.3f%n", "Maxima",
                ordenadas[ordenadas.length - 1] / 1000.0);
    }

    private long percentil(long[] ordenadas, int p) {
        // Indice del percentil sobre el array ya ordenado.
        int indice = (int) Math.ceil(p / 100.0 * ordenadas.length) - 1;
        return ordenadas[Math.max(0, Math.min(indice, ordenadas.length - 1))];
    }

    public static void main(String[] args) throws InterruptedException {
        String host = args.length > 0 ? args[0] : "localhost";
        int puerto = args.length > 1 ? Integer.parseInt(args[1]) : 9090;

        for (int clientes : new int[]{4, 16, 64}) {
            System.out.println("############ " + clientes + " CLIENTES ############");
            new PruebaCarga(host, puerto).ejecutar(clientes, 200);
            System.out.println();
            Thread.sleep(1000);     // margen para que el servidor se recupere
        }
    }
}

############ 4 CLIENTES ############
Lanzando 4 clientes x 200 peticiones = 800 peticiones

=== RESULTADO DE LA PRUEBA DE CARGA ===
Duracion total             0,42 s
Peticiones correctas       800
Peticiones con error       0
Conexiones fallidas        0
Peticiones por segundo     1897

--- LATENCIAS (ms) ---
Minima                     0,118
Media                      0,204
Mediana (p50)              0,171
p95                        0,392
p99                        0,884
Maxima                     4,113

############ 16 CLIENTES ############
Peticiones por segundo     6104
Mediana (p50)              0,224
p95                        0,668
p99                        1,942
Maxima                     11,208

############ 64 CLIENTES ############
Conexiones fallidas        0
Peticiones por segundo     6438
Mediana (p50)              1,102
p95                        4,873
p99                        12,441
Maxima                     58,306