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

// El constructor fa el "bind": reserva el port 9090 per a aquest proces.
try (ServerSocket servidor = new ServerSocket(9090)) {

    System.out.println("Escoltant al port " + servidor.getLocalPort());

    // accept() BLOQUEJA fins que arriba una connexio.
    // Quan torna, retorna un Socket JA CONNECTAT al client.
    Socket connexio = servidor.accept();

    System.out.println("Client connectat des de " + connexio.getRemoteSocketAddress());

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

// 1. Port. El minim.
new ServerSocket(9090);

// 2. Port + backlog: mida de la cua de connexions pendents.
new ServerSocket(9090, 100);

// 3. Port + backlog + adreca d'escolta.
new ServerSocket(9090, 100, InetAddress.getByName("127.0.0.1"));

// 4. Sense connectar, per configurar abans del bind (ho veurem a l'apartat 4).
ServerSocket s = new ServerSocket();
s.setReuseAddress(true);
s.bind(new InetSocketAddress(9090), 100);

                 cua de pendents (backlog = 3)
  clients   -->  [ conn ][ conn ][ conn ]  -->  accept()  -->  el teu codi
  nous                                                         (un cada vegada)

  Si la cua esta plena, el SO rebutja les connexions noves
  i el client rep ConnectException: Connection refused.

try (ServerSocket servidor = new ServerSocket(0)) {
    int portReal = servidor.getLocalPort();        // per exemple, 43127
    System.out.println("El sistema m'ha donat el port " + portReal);
}

Socket connexio = servidor.accept();

servidor.setSoTimeout(1000);        // sondeig cada segon
while (executant) {
    try {
        Socket connexio = servidor.accept();
        atendre(connexio);
    } catch (SocketTimeoutException e) {
        // Un segon sense connexions: aprofitem per comprovar
        // el marcador d'aturada i tornem 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          # i si es resisteix, kill -9 4711

lsof -i :9090
netstat -an | grep 9090

// La forma correcta: crear SENSE lligar, configurar, i despres lligar.
ServerSocket servidor = new ServerSocket();
servidor.setReuseAddress(true);                       // ABANS del bind
servidor.bind(new InetSocketAddress(9090), 100);

package com.nexussoftware.bibliotech.xarxa;

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 d'eco SEQUENCIAL: aten un client cada vegada.
 * Serveix per demostrar el limit del model, no per fer-lo servir.
 */
public class ServidorSequencial {

    private static final Logger LOG = Logger.getLogger(ServidorSequencial.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 sequencial escoltant al 9090");

        try (servidor) {
            while (true) {
                // S'accepta UNA connexio...
                Socket connexio = servidor.accept();
                LOG.info(() -> "Connexio de " + connexio.getRemoteSocketAddress());

                // ...i s'aten SENCERA abans de tornar a l'accept().
                // Mentre dura aquesta conversa, no s'aten ningu mes.
                try (connexio) {
                    connexio.setSoTimeout(60_000);
                    atendre(connexio);
                } catch (IOException e) {
                    LOG.warning("Fallada atenent la connexio: " + e.getMessage());
                }

                LOG.info("Connexio acabada; torno a l'accept()");
            }
        }
    }

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

        escriptor.println("200 SERVIDOR D'ECO. Escriu SORTIR per acabar.");

        String linia;
        while ((linia = lector.readLine()) != null) {
            if (linia.equalsIgnoreCase("SORTIR")) {
                escriptor.println("221 ADEU");
                return;
            }
            escriptor.println("ECO: " + linia);
        }
        // readLine() ha retornat null: el client ha tancat sense acomiadar-se.
    }
}

TERMINAL 1 (primer client)           TERMINAL 2 (segon client)
------------------------------       ------------------------------
$ telnet localhost 9090              $ telnet localhost 9090
Trying 127.0.0.1...                  Trying 127.0.0.1...
Connected to localhost.              Connected to localhost.
200 SERVIDOR D'ECO. Escriu...        _
hola                                 (res. No hi ha salutacio.
ECO: hola                             La connexio TCP esta feta,
                                      pero el servidor no ha cridat
                                      accept() i no llegeix res)

TERMINAL 1                           TERMINAL 2
------------------------------       ------------------------------
SORTIR                               200 SERVIDOR D'ECO. Escriu...
221 ADEU                             (ara si! En alliberar-se el fil,
Connection closed.                    l'accept() recull aquesta connexio)

INFO: Servidor sequencial escoltant al 9090
INFO: Connexio de /127.0.0.1:52310
INFO: Connexio acabada; torno a l'accept()
INFO: Connexio de /127.0.0.1:52311

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

    // Un fil nou per connexio. El bucle torna a l'accept() a l'instant.
    Thread fil = new Thread(() -> {
        try (connexio) {
            atendre(connexio);
        } catch (IOException e) {
            LOG.warning("Fallada atenent: " + e.getMessage());
        }
    }, "client-" + connexio.getPort());
    fil.start();
}

package com.nexussoftware.bibliotech.xarxa;

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 fils amb noms llegibles. Un fil anomenat "bibliotech-client-3"
 * en un bolcat de fils o en una linia de log val mil vegades mes que
 * "pool-1-thread-3". Aixo es 08-02 i 08-05 aplicats.
 */
public class FabricaFilsServidor implements ThreadFactory {

    private final String prefix;
    private final AtomicInteger comptador = new AtomicInteger(1);

    public FabricaFilsServidor(String prefix) {
        this.prefix = prefix;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread fil = new Thread(r, prefix + "-" + comptador.getAndIncrement());
        // NO daemon: volem que l'aturada sigui explicita i ordenada,
        // no que la JVM mati converses a mitges en acabar el main.
        fil.setDaemon(false);
        return fil;
    }
}

// Pool acotat amb ThreadPoolExecutor: control total sobre el comportament.
ThreadPoolExecutor pool = new ThreadPoolExecutor(
        8,                                     // fils nucli: sempre vius
        8,                                     // maxim: acotat, sense sorpreses
        60L, TimeUnit.SECONDS,                 // temps ocios abans de morir
        new LinkedBlockingQueue<>(100),        // cua ACOTADA de tasques en espera
        new FabricaFilsServidor("bibliotech-client"),
        new ThreadPoolExecutor.AbortPolicy()); // que fer si no hi cap

try {
    pool.execute(() -> atendreConnexio(connexio));
} catch (RejectedExecutionException e) {
    // El servidor esta saturat. Li ho diem al client i tanquem.
    // Rebutjar rapid es MILLOR que acceptar i no respondre.
    rebutjarEducadament(connexio, "503 SERVIDOR SATURAT");
}

private volatile boolean executant = true;
private ServerSocket servidor;

/** Bucle principal. S'executa al fil acceptador. */
public void executar() {
    while (executant) {
        try {
            Socket connexio = servidor.accept();
            pool.execute(() -> atendre(connexio));

        } catch (SocketException e) {
            // Pot ser una fallada real O el nostre propi tancament.
            // El marcador 'executant' distingeix els dos casos:
            // sense ell, una aturada normal apareix al log com un error greu.
            if (!executant) {
                LOG.info("ServerSocket tancat: fi ordenat del bucle d'acceptacio");
                break;
            }
            LOG.log(Level.SEVERE, "Fallada inesperada a accept()", e);
            break;

        } catch (IOException e) {
            // Una fallada acceptant UNA connexio no ha de tombar el servidor:
            // es registra i es continua acceptant.
            LOG.log(Level.WARNING, "Error acceptant una connexio", e);
        }
    }
}

/** Es crida des d'un altre fil (menu, shutdown hook, senyal). */
public void aturar() {
    executant = false;               // 1. marcador volatile: es veu des de l'altre fil
    tancarSilenciosament(servidor);  // 2. aixo desbloqueja l'accept() a l'instant
    // 3. i despres, l'aturada en dues fases del pool
}

public void aturar() {
    executant = false;
    tancarSilenciosament(servidor);

    // FASE 1: no s'accepten tasques noves, pero les que estan en curs acaben.
    pool.shutdown();
    try {
        // Donem un termini raonable perque les converses acabin soles.
        if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
            LOG.warning("Converses encara actives despres de 10 s: es forca el tancament");

            // FASE 2: interrupcio dels fils que quedin.
            pool.shutdownNow();

            if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                LOG.severe("El pool no ha acabat; hi ha fils encallats");
            }
        }
    } catch (InterruptedException e) {
        // Ens han interromput esperant: forcem i RESTAUREM el marcador.
        pool.shutdownNow();
        Thread.currentThread().interrupt();    // 08-02: mai no s'empassa la interrupcio
    }
}

// Dins del fil que aten la Marta, i alhora dins del que aten en Diego,
// i alhora dins del que aten la Nuria:
Material material = cataleg.cercarPerIsbn(isbn);       // segur: ConcurrentHashMap
cataleg.registrarConsulta();                           // segur: LongAdder

package com.nexussoftware.bibliotech.xarxa;

import com.nexussoftware.bibliotech.domini.Material;
import com.nexussoftware.bibliotech.servei.CatalegConcurrent;
import com.nexussoftware.bibliotech.servei.RegistrePrestecsSegur;

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 protocol BTCP/1 de BiblioTech.
 *
 * - Un fil acceptador que nomes accepta i delega.
 * - Un pool ACOTAT de fils que atenen les converses (modul 8).
 * - Estat compartit a CatalegConcurrent (ConcurrentHashMap): ja era segur.
 * - Validacio estricta de tot el que arriba per la xarxa.
 * - setSoTimeout per connexio per expulsar clients inactius.
 * - Aturada ordenada en dues fases.
 */
public class ServidorCataleg implements AutoCloseable {

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

    // --- Limits defensius: tots els valors que venen de la xarxa s'acoten ---
    /** Cap peticio BTCP/1 legitima no passa d'aixo. Evita l'esgotament de memoria. */
    private static final int MAXIMA_LONGITUD_LINIA = 512;
    /** Peticions seguides per connexio: evita que un client monopolitzi un fil. */
    private static final int MAXIM_PETICIONS = 1_000;
    /** Un ISBN de BiblioTech te aquesta forma i res mes. */
    private static final int MAXIM_ISBN = 20;
    private static final int MAXIM_EMPLEAT = 60;

    private final int port;
    private final String adrecaEscolta;
    private final int fils;
    private final int cuaEspera;
    private final int limitInactivitatMs;

    private final CatalegConcurrent cataleg;
    private final RegistrePrestecsSegur prestecs;

    private ServerSocket servidor;
    private ThreadPoolExecutor pool;

    /** volatile: l'escriu el fil que atura, la llegeix el fil acceptador (08-04). */
    private volatile boolean executant = false;

    private final AtomicInteger connexionsActives = new AtomicInteger();
    private final AtomicLong connexionsTotals = new AtomicLong();
    private final AtomicLong peticionsAteses = new AtomicLong();
    private final AtomicLong connexionsRebutjades = new AtomicLong();

    public ServidorCataleg(int port, String adrecaEscolta, int fils,
                           int cuaEspera, int limitInactivitatMs,
                           CatalegConcurrent cataleg,
                           RegistrePrestecsSegur prestecs) {
        this.port = port;
        this.adrecaEscolta = adrecaEscolta;
        this.fils = fils;
        this.cuaEspera = cuaEspera;
        this.limitInactivitatMs = limitInactivitatMs;
        this.cataleg = cataleg;
        this.prestecs = prestecs;
    }

    // =================================================================
    // Arrencada
    // =================================================================

    /** Prepara el socket i el pool. No bloqueja. */
    public void arrencar() throws IOException {
        // Patro de tres passos: crear sense lligar, configurar, lligar.
        // setReuseAddress HA d'anar abans del bind, o no serveix de res.
        servidor = new ServerSocket();
        servidor.setReuseAddress(true);
        servidor.bind(new InetSocketAddress(adrecaEscolta, port), cuaEspera);

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

            @Override
            public Thread newThread(Runnable r) {
                // Noms llegibles: en un bolcat de fils i en cada linia
                // de log sabras exactament qui fa que (08-02).
                Thread f = new Thread(r, "bibliotech-client-" + n.getAndIncrement());
                f.setDaemon(false);
                return f;
            }
        };

        pool = new ThreadPoolExecutor(
                fils, fils,
                60L, TimeUnit.SECONDS,
                // Cua ACOTADA: newFixedThreadPool en fa servir una sense limit i aixo
                // converteix una saturacio en un OutOfMemoryError.
                new LinkedBlockingQueue<>(cuaEspera),
                fabrica,
                // Rebutjar rapid i dir-ho al client es millor que
                // acceptar i no respondre.
                new ThreadPoolExecutor.AbortPolicy());

        executant = true;
        LOG.info(() -> "ServidorCataleg BTCP/1 escoltant a "
                + adrecaEscolta + ":" + port
                + " (pool=" + fils + ", cua=" + cuaEspera + ")");
    }

    /** Bucle d'acceptacio. Bloqueja fins que es crida close(). */
    public void executar() {
        while (executant) {
            Socket connexio = null;
            try {
                connexio = servidor.accept();       // BLOQUEJA aqui

                // Temps limit d'INACTIVITAT per connexio. Es el que expulsa
                // els clients que connecten i es callen, i a mes el que
                // permet que shutdownNow() aconsegueixi aturar els fils.
                connexio.setSoTimeout(limitInactivitatMs);
                connexio.setTcpNoDelay(true);       // protocol interactiu: sense Nagle

                final Socket acceptada = connexio;
                connexionsTotals.incrementAndGet();

                // El fil acceptador NO aten: delega i torna a l'accept().
                pool.execute(() -> atendreConnexio(acceptada));

            } catch (RejectedExecutionException e) {
                // Pool i cua plens: el servidor esta saturat.
                connexionsRebutjades.incrementAndGet();
                LOG.warning("Servidor saturat; connexio rebutjada");
                rebutjar(connexio, "503 SERVIDOR SATURAT");

            } catch (SocketException e) {
                // El nostre propi close() O una fallada real. El marcador decideix.
                if (!executant) {
                    LOG.info("Bucle d'acceptacio acabat ordenadament");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallada inesperada a accept()", e);
                return;

            } catch (IOException e) {
                // Una fallada acceptant UNA connexio no tomba el servidor.
                LOG.log(Level.WARNING, "Error acceptant una connexio", e);
                tancarSilenciosament(connexio);
            }
        }
    }

    // =================================================================
    // Atencio d'una connexio (s'executa en un fil del pool)
    // =================================================================

    private void atendreConnexio(Socket connexio) {
        String client = String.valueOf(connexio.getRemoteSocketAddress());
        int actives = connexionsActives.incrementAndGet();
        LOG.info(() -> "[" + client + "] connectat (" + actives + " actives)");

        // try-with-resources: el socket es tanca passi el que passi.
        try (connexio) {
            BufferedReader lector = new BufferedReader(
                    new InputStreamReader(connexio.getInputStream(),
                            StandardCharsets.UTF_8));
            PrintWriter escriptor = new PrintWriter(
                    new BufferedWriter(
                            new OutputStreamWriter(connexio.getOutputStream(),
                                    StandardCharsets.UTF_8)),
                    false);     // sense autoFlush: buidem a ma despres de cada resposta

            // El servidor parla primer, com especifica el protocol.
            respondre(escriptor, "200 BIBLIOTECH BTCP/1");

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

                if (peticions++ >= MAXIM_PETICIONS) {
                    // Un client no pot quedar-se amb un fil indefinidament.
                    respondre(escriptor, "421 MASSA PETICIONS");
                    LOG.warning("[" + client + "] ha superat el limit de peticions");
                    return;
                }

                String linia = llegirLiniaAcotada(lector);
                if (linia == null) {
                    LOG.info(() -> "[" + client + "] ha tancat la connexio");
                    return;
                }

                peticionsAteses.incrementAndGet();
                boolean continuar = processar(linia, escriptor, client);
                if (!continuar) {
                    return;
                }
            }

        } catch (SocketTimeoutException e) {
            // El client ha connectat i s'ha callat. Se l'expulsa: el fil torna al pool.
            LOG.info(() -> "[" + client + "] expulsat per inactivitat ("
                    + limitInactivitatMs + " ms)");

        } catch (LiniaMassaLlargaException e) {
            LOG.warning("[" + client + "] ha enviat una linia de mes de "
                    + MAXIMA_LONGITUD_LINIA + " caracters; connexio tallada");

        } catch (SocketException e) {
            // "Connection reset": el client ha caigut. Es normal, no es un error greu.
            LOG.info(() -> "[" + client + "] connexio perduda: " + e.getMessage());

        } catch (IOException e) {
            LOG.log(Level.WARNING, "[" + client + "] fallada d'E/S", e);

        } catch (RuntimeException e) {
            // Una fallada de programacio en la gestio d'UN client no pot
            // matar el fil del pool ni afectar els altres. Aquest catch
            // es la frontera d'errors de 06-07 aplicada a cada connexio.
            LOG.log(Level.SEVERE, "[" + client + "] fallada inesperada", e);

        } finally {
            int queden = connexionsActives.decrementAndGet();
            LOG.info(() -> "[" + client + "] desconnectat (" + queden + " actives)");
        }
    }

    // =================================================================
    // Processament d'una peticio
    // =================================================================

    /** Retorna false si cal tancar la connexio despres d'aquesta peticio. */
    private boolean processar(String linia, PrintWriter escriptor, String client) {
        // Se separa l'ordre de la resta pel PRIMER espai: el nom
        // d'empleat pot portar espais i no el volem partir.
        String ordre;
        String resta;
        int espai = linia.indexOf(' ');
        if (espai < 0) {
            ordre = linia;
            resta = "";
        } else {
            ordre = linia.substring(0, espai);
            resta = linia.substring(espai + 1).strip();
        }

        // Les ordres es comparen en majuscules per ser tolerants,
        // pero el protocol les documenta en majuscules.
        switch (ordre.toUpperCase()) {

            case "CONSULTA" -> {
                if (!isbnValid(resta)) {
                    respondre(escriptor, "400 PETICIO INVALIDA isbn no valid");
                    return true;
                }
                Material material = cataleg.cercarPerIsbn(resta);
                if (material == null) {
                    respondre(escriptor, "404 NO TROBAT " + resta);
                } else {
                    respondre(escriptor, "200 OK " + formatar(material));
                }
                return true;
            }

            case "LLISTA" -> {
                if (!resta.isEmpty()) {
                    respondre(escriptor, "400 PETICIO INVALIDA LLISTA no admet arguments");
                    return true;
                }
                List<Material> materials = cataleg.tots();
                respondre(escriptor, "201 LLISTA " + materials.size());
                for (Material m : materials) {
                    respondre(escriptor, formatar(m));
                }
                respondre(escriptor, ".");
                return true;
            }

            case "PRESTAR" -> {
                int sep = resta.indexOf(' ');
                if (sep < 0) {
                    respondre(escriptor, "400 PETICIO INVALIDA falten arguments");
                    return true;
                }
                String isbn = resta.substring(0, sep);
                String empleat = resta.substring(sep + 1).strip();

                if (!isbnValid(isbn) || !empleatValid(empleat)) {
                    respondre(escriptor, "400 PETICIO INVALIDA arguments no valids");
                    return true;
                }
                if (cataleg.cercarPerIsbn(isbn) == null) {
                    respondre(escriptor, "404 NO TROBAT " + isbn);
                    return true;
                }

                // OPERACIO COMPOSTA ATOMICA: comprovar disponibilitat i prestar
                // en una sola crida al servei. Encadenar dues operacions
                // segures NO dona una operacio segura (08-06).
                boolean prestat = prestecs.prestarSiDisponible(isbn, empleat);
                if (prestat) {
                    LOG.info(() -> "[" + client + "] prestec de " + isbn
                            + " a " + empleat);
                    respondre(escriptor, "200 OK prestec registrat");
                } else {
                    respondre(escriptor, "409 NO DISPONIBLE " + isbn);
                }
                return true;
            }

            case "SORTIR" -> {
                respondre(escriptor, "221 ADEU");
                return false;       // tancar la connexio
            }

            default -> {
                // NO retornem l'ordre tal qual al client sense sanejar:
                // podria contenir sequencies d'escapada de terminal.
                respondre(escriptor, "400 PETICIO INVALIDA ordre desconeguda: "
                        + sanejar(ordre));
                return true;
            }
        }
    }

    private String formatar(Material m) {
        return m.getIsbn() + "|" + m.getTitol() + "|"
                + m.getTipus() + "|" + m.estaDisponible();
    }

    // =================================================================
    // E/S de baix nivell del protocol
    // =================================================================

    /** Escriu una linia del protocol i BUIDA. Sense flush, el client espera eternament. */
    private void respondre(PrintWriter escriptor, String linia) {
        escriptor.print(linia + "\n");      // \n explicit: el protocol ho exigeix
        escriptor.flush();                  // OBLIGATORI
        if (escriptor.checkError()) {
            // PrintWriter s'empassa les IOException; checkError es l'unica pista.
            LOG.fine("Fallada en escriure la resposta; el client probablement ha tancat");
        }
    }

    /** Excepcio interna per a una linia que excedeix el limit. */
    private static class LiniaMassaLlargaException extends IOException {
        LiniaMassaLlargaException(String m) {
            super(m);
        }
    }

    /**
     * Llegeix una linia ACOTADA. BufferedReader.readLine() no te limit:
     * un client malicios pot enviar 100 MB sense ni un salt de linia
     * i esgotar la memoria del servidor. Aquesta es una defensa obligatoria
     * en qualsevol servidor exposat.
     */
    private String llegirLiniaAcotada(BufferedReader lector) throws IOException {
        StringBuilder sb = new StringBuilder();
        int c;
        while ((c = lector.read()) != -1) {
            if (c == '\n') {
                // Acceptem tambe \r\n traient el retorn de carro final.
                int fi = sb.length();
                if (fi > 0 && sb.charAt(fi - 1) == '\r') {
                    sb.setLength(fi - 1);
                }
                return sb.toString();
            }
            if (sb.length() >= MAXIMA_LONGITUD_LINIA) {
                throw new LiniaMassaLlargaException(
                        "Linia de mes de " + MAXIMA_LONGITUD_LINIA + " caracters");
            }
            sb.append((char) c);
        }
        // Fi de flux. Si hi havia alguna cosa a mitges, es descarta: no es una linia valida.
        return null;
    }

    // =================================================================
    // Validacio: NO confiar MAI en el que arriba per la xarxa
    // =================================================================

    private boolean isbnValid(String isbn) {
        if (isbn == null || isbn.isBlank() || isbn.length() > MAXIM_ISBN) {
            return false;
        }
        // Llista BLANCA de caracters: nomes digits i guions. Tota la resta fora.
        // Una llista blanca es sempre mes segura que una llista 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 empleatValid(String empleat) {
        if (empleat == null || empleat.isBlank() || empleat.length() > MAXIM_EMPLEAT) {
            return false;
        }
        for (int i = 0; i < empleat.length(); i++) {
            char c = empleat.charAt(i);
            // Lletres, digits, espais, guions baixos i guions. Res de
            // caracters de control, que trencarien el protocol o el log.
            if (!Character.isLetterOrDigit(c) && c != ' ' && c != '_' && c != '-') {
                return false;
            }
        }
        return true;
    }

    /**
     * Saneja un text que ve de la xarxa abans de retornar-lo o registrar-lo.
     * Sense aixo, un client pot injectar \n (una resposta falsa al
     * protocol) o sequencies d'escapada ANSI (que manipulen el terminal
     * de qui llegeixi el log). Es INJECCIO DE LOG, un problema real.
     */
    private String sanejar(String text) {
        StringBuilder sb = new StringBuilder();
        int limit = Math.min(text.length(), 40);
        for (int i = 0; i < limit; i++) {
            char c = text.charAt(i);
            sb.append(Character.isISOControl(c) ? '?' : c);
        }
        return sb.toString();
    }

    // =================================================================
    // Aturada ordenada
    // =================================================================

    @Override
    public void close() {
        if (!executant) {
            return;
        }
        LOG.info("Apagant ServidorCataleg...");

        // 1. Marcador ABANS del tancament: distingeix l'aturada neta d'una fallada.
        executant = false;

        // 2. Tancar el ServerSocket es l'UNICA cosa que desbloqueja accept().
        //    Thread.interrupt() no ho aconsegueix.
        tancarSilenciosament(servidor);

        // 3. Aturada en dues fases del pool (08-05).
        if (pool != null) {
            pool.shutdown();        // no admet tasques noves; les actuals continuen
            try {
                if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
                    LOG.warning("Converses actives despres de 10 s: es forca el tancament");
                    pool.shutdownNow();     // interromp els fils
                    if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                        LOG.severe("Queden fils sense acabar");
                    }
                }
            } catch (InterruptedException e) {
                pool.shutdownNow();
                Thread.currentThread().interrupt();   // 08-02: restaurar el marcador
            }
        }

        LOG.info(() -> String.format(
                "ServidorCataleg aturat. Connexions: %d totals, %d rebutjades. "
                + "Peticions ateses: %d",
                connexionsTotals.get(), connexionsRebutjades.get(),
                peticionsAteses.get()));
    }

    private void rebutjar(Socket connexio, String missatge) {
        if (connexio == null) {
            return;
        }
        // Cortesia: dir al client per que se li tanca, en lloc de
        // tallar-lo sense explicacio. Costa dues linies i estalvia suport.
        try (connexio) {
            PrintWriter escriptor = new PrintWriter(
                    new OutputStreamWriter(connexio.getOutputStream(),
                            StandardCharsets.UTF_8));
            escriptor.print(missatge + "\n");
            escriptor.flush();
        } catch (IOException e) {
            LOG.fine("No s'ha pogut notificar el rebuig: " + e.getMessage());
        }
    }

    private void tancarSilenciosament(java.io.Closeable recurs) {
        if (recurs != null) {
            try {
                recurs.close();
            } catch (IOException ignorada) {
                // Tancant ja no hi ha res a salvar.
            }
        }
    }

    // --- Metriques per al menu de BiblioTech ---

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

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

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

package com.nexussoftware.bibliotech.presentacio;

import com.nexussoftware.bibliotech.persistencia.Configuracio;
import com.nexussoftware.bibliotech.xarxa.ServidorCataleg;
import com.nexussoftware.bibliotech.servei.CatalegConcurrent;
import com.nexussoftware.bibliotech.servei.RegistrePrestecsSegur;
import com.nexussoftware.bibliotech.infra.ConfiguracioLog;

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

/** Arrencada del servidor de cataleg de BiblioTech. */
public class ServidorBiblioTechApp {

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

    public static void main(String[] args) throws IOException {
        ConfiguracioLog.inicialitzar();     // el logger del modul 6, ja configurat

        // La configuracio surt de bibliotech.properties (07-07).
        Configuracio config = Configuracio.carregar();
        int port = config.enter("xarxa.port", 9090);
        String escolta = config.text("xarxa.escolta", "0.0.0.0");
        int fils = config.enter("xarxa.fils", 16);
        int cua = config.enter("xarxa.cua", 100);
        int inactivitat = config.enter("xarxa.inactivitat.ms", 60_000);

        CatalegConcurrent cataleg = CatalegConcurrent.carregarDesDeFitxer();
        RegistrePrestecsSegur prestecs = new RegistrePrestecsSegur(cataleg);

        ServidorCataleg servidor = new ServidorCataleg(
                port, escolta, fils, cua, inactivitat, cataleg, prestecs);
        servidor.arrencar();

        // Shutdown hook: s'executa amb Ctrl+C o amb SIGTERM (que es el que
        // envia Docker, systemd o Kubernetes en aturar un contenidor).
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            LOG.info("Senyal d'aturada rebut");
            servidor.close();
        }, "bibliotech-aturada"));

        // Bloqueja aqui fins que el ServerSocket es tanqui.
        servidor.executar();

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

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

INFO: ServidorCataleg BTCP/1 escoltant a 0.0.0.0:9090 (pool=16, cua=100)

telnet localhost 9090

Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
200 BIBLIOTECH BTCP/1
CONSULTA 978-0000000001                                  <-- TECLEJA
200 OK 978-0000000001|Java Eficac|LLIBRE|true
CONSULTA 999                                             <-- TECLEJA
404 NO TROBAT 999
CONSULTA ../../etc/passwd                                <-- TECLEJA
400 PETICIO INVALIDA isbn no valid
LLISTA                                                   <-- TECLEJA
201 LLISTA 3
978-0000000001|Java Eficac|LLIBRE|true
978-0000000002|Patrons de Disseny|LLIBRE|false
978-0000000003|Refactoritzacio|LLIBRE|true
.
PRESTAR 978-0000000003 Nuria Vidal                       <-- TECLEJA
200 OK prestec registrat
PRESTAR 978-0000000003 Diego Alonso                      <-- TECLEJA
409 NO DISPONIBLE 978-0000000003
DEMANA UN CAFE                                           <-- TECLEJA
400 PETICIO INVALIDA ordre desconeguda: DEMANA
SORTIR                                                   <-- TECLEJA
221 ADEU
Connection closed by foreign host.

printf 'LLISTA\nSORTIR\n' | nc localhost 9090

200 BIBLIOTECH BTCP/1
201 LLISTA 3
978-0000000001|Java Eficac|LLIBRE|true
978-0000000002|Patrons de Disseny|LLIBRE|false
978-0000000003|Refactoritzacio|LLIBRE|true
.
221 ADEU

INFO: [/127.0.0.1:52440] connectat (1 actives)
INFO: [/127.0.0.1:52441] connectat (2 actives)
INFO: [/127.0.0.1:52441] prestec de 978-0000000003 a Nuria Vidal
INFO: [/127.0.0.1:52442] connectat (3 actives)
INFO: [/127.0.0.1:52442] ha tancat la connexio
INFO: [/127.0.0.1:52442] desconnectat (2 actives)
INFO: [/127.0.0.1:52441] desconnectat (1 actives)
INFO: [/127.0.0.1:52440] desconnectat (0 actives)

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    LOG.info("Senyal d'aturada rebut");
    servidor.close();
}, "bibliotech-aturada"));

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    LOG.info("Apagant BiblioTech...");
    servidor.close();                  // 1. deixar d'acceptar i tancar converses
    AturadaOrdenada.aturarServeis();   // 2. pools d'avisos, manteniment, reserves
    MagatzemPrestecs.bolcar();         // 3. persistir el pendent (modul 7)
    LOG.info("BiblioTech aturat correctament");
}, "bibliotech-aturada"));

// E/S no bloquejant: UN fil aten milers de connexions.
Selector selector = Selector.open();
ServerSocketChannel canal = ServerSocketChannel.open();
canal.bind(new InetSocketAddress(9090));
canal.configureBlocking(false);                          // clau: no bloquejant
canal.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();          // bloqueja fins que ALGUN canal te activitat
    for (SelectionKey clau : selector.selectedKeys()) {
        if (clau.isAcceptable()) { /* acceptar */ }
        if (clau.isReadable())   { /* llegir el que hi hagi, sense bloquejar */ }
    }
}

// Java 21+: un fil VIRTUAL per connexio. Sense pool, sense limit practic.
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    while (executant) {
        Socket connexio = servidor.accept();
        executor.submit(() -> atendreConnexio(connexio));
    }
}

package com.nexussoftware.bibliotech.xarxa;

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 d'estadistiques de BiblioTech.
 *
 * SEGURETAT: escolta NOMES a 127.0.0.1. Les metriques d'un servei revelen
 * informacio util per a un atacant (carrega, saturacio, memoria, finestres de
 * baixa activitat) i solen ser el primer lloc on es filtra alguna cosa sense voler.
 * Exposar-les a la xarxa seria una fallada de disseny; si s'han de consultar des de
 * fora, es fa per un tunel SSH o darrere d'un proxy autenticat (12-07).
 */
public class ServidorEstadistiques implements AutoCloseable {

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

    private final int port;
    private final ServidorCataleg principal;
    private final ThreadPoolExecutor poolPrincipal;
    private final ExecutorService pool;
    private final long instantArrencada = System.currentTimeMillis();

    private ServerSocket servidor;
    private volatile boolean executant = false;

    public ServidorEstadistiques(int port, ServidorCataleg principal,
                                 ThreadPoolExecutor poolPrincipal, ExecutorService pool) {
        this.port = port;
        this.principal = principal;
        this.poolPrincipal = poolPrincipal;
        this.pool = pool;       // es comparteix el pool: no calen fils propis
    }

    public void arrencar() throws IOException {
        servidor = new ServerSocket();
        servidor.setReuseAddress(true);
        // El tercer argument del bind LLIGA l'escolta al bucle invertit:
        // ni tan sols una fallada de tallafoc exposaria aquest port.
        servidor.bind(new InetSocketAddress(
                InetAddress.getLoopbackAddress(), port), 10);
        executant = true;

        // Fil acceptador propi, perque accept() bloqueja.
        Thread acceptador = new Thread(this::executar, "bibliotech-stats-acceptador");
        acceptador.setDaemon(true);     // aquest si que pot ser daemon: no te estat
        acceptador.start();

        LOG.info(() -> "Servidor d'estadistiques a 127.0.0.1:" + port);
    }

    private void executar() {
        while (executant) {
            try {
                Socket connexio = servidor.accept();
                connexio.setSoTimeout(5_000);
                // Es delega al pool compartit: no atenem a l'acceptador.
                pool.execute(() -> servirInforme(connexio));

            } catch (SocketException e) {
                if (!executant) {
                    LOG.info("Servidor d'estadistiques aturat");
                    return;
                }
                LOG.log(Level.SEVERE, "Fallada a accept() d'estadistiques", e);
                return;

            } catch (IOException e) {
                LOG.log(Level.WARNING, "Error acceptant connexio d'estadistiques", e);
            }
        }
    }

    /**
     * Aquest servei no te protocol: en connectar, escriu i tanca.
     * Es el que permet consultar-lo amb un simple "nc localhost 9092".
     */
    private void servirInforme(Socket connexio) {
        try (connexio) {
            BufferedWriter escriptor = new BufferedWriter(
                    new OutputStreamWriter(connexio.getOutputStream(),
                            StandardCharsets.UTF_8));
            escriptor.write(construirInforme());
            escriptor.flush();      // el buidatge de sempre
        } catch (IOException e) {
            LOG.fine("Fallada servint l'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 segons = (System.currentTimeMillis() - instantArrencada) / 1000;

        StringBuilder sb = new StringBuilder();
        sb.append("=== BIBLIOTECH - ESTAT DEL SERVIDOR ===\n");
        sb.append(String.format("%-28s %s%n", "En marxa des de fa",
                formatarDuracio(segons)));
        sb.append('\n');
        sb.append("--- CONNEXIONS ---\n");
        sb.append(String.format("%-28s %d%n", "Actives", principal.connexionsActives()));
        sb.append(String.format("%-28s %d%n", "Totals", principal.connexionsTotals()));
        sb.append(String.format("%-28s %d%n", "Peticions ateses",
                principal.peticionsAteses()));
        sb.append('\n');
        sb.append("--- POOL DE FILS ---\n");
        sb.append(String.format("%-28s %d%n", "Fils actius",
                poolPrincipal.getActiveCount()));
        sb.append(String.format("%-28s %d%n", "Mida del pool",
                poolPrincipal.getPoolSize()));
        sb.append(String.format("%-28s %d%n", "Tasques en cua",
                poolPrincipal.getQueue().size()));
        sb.append(String.format("%-28s %d%n", "Tasques completades",
                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", "Nuclis disponibles",
                rt.availableProcessors()));
        return sb.toString();
    }

    private String formatarDuracio(long segons) {
        // Sense java.time (aixo es 10-05): aritmetica simple sobre enters.
        long h = segons / 3600;
        long m = (segons % 3600) / 60;
        long s = segons % 60;
        return String.format("%dh %02dm %02ds", h, m, s);
    }

    @Override
    public void close() {
        executant = false;
        try {
            if (servidor != null) {
                servidor.close();       // desbloqueja l'accept()
            }
        } catch (IOException ignorada) {
            // Tancant ja no hi ha res a salvar.
        }
    }
}

nc localhost 9092

=== BIBLIOTECH - ESTAT DEL SERVIDOR ===
En marxa des de fa           0h 04m 17s

--- CONNEXIONS ---
Actives                      2
Totals                       47
Peticions ateses             183

--- POOL DE FILS ---
Fils actius                  2
Mida del pool                16
Tasques en cua               0
Tasques completades          45

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

package com.nexussoftware.bibliotech.xarxa;

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 connexions simultanies per adreca IP.
 *
 * Evita que un sol equip (per error o a proposit) ocupi tot el pool
 * de fils del servidor i deixi sense servei els altres llocs de treball.
 */
public class LimitadorPerIp {

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

    private final int maximPerIp;
    private final boolean eximirBucleInvertit;

    /** Compta connexions actives per IP. Concurrent: la toquen tots els fils. */
    private final ConcurrentHashMap<String, AtomicInteger> perIp = new ConcurrentHashMap<>();
    private final AtomicLong rebutjadesPerLimit = new AtomicLong();

    public LimitadorPerIp(int maximPerIp, boolean eximirBucleInvertit) {
        this.maximPerIp = maximPerIp;
        this.eximirBucleInvertit = eximirBucleInvertit;
    }

    /**
     * Intenta reservar una placa per a aquesta IP.
     * Retorna true si s'admet; false si s'ha assolit el limit.
     */
    public boolean admetre(Socket connexio) {
        String ip = ipDe(connexio);

        if (eximirBucleInvertit && esBucleInvertit(ip)) {
            // Sense l'exempcio, provar el servidor amb diversos telnet des de
            // la propia maquina seria impossible.
            return true;
        }

        // computeIfAbsent es atomic: si dos fils hi arriben alhora amb la
        // mateixa IP, nomes un crea l'AtomicInteger i tots dos fan servir el mateix.
        AtomicInteger comptador = perIp.computeIfAbsent(ip, clau -> new AtomicInteger());

        // Bucle de comparar-i-intercanviar: la forma atomica de dir
        // "incrementa NOMES SI el valor actual es menor que el maxim".
        // Un "if (get() < max) incrementAndGet()" tindria una cursa:
        // dos fils podrien passar l'if alhora i superar el limit.
        while (true) {
            int actual = comptador.get();
            if (actual >= maximPerIp) {
                rebutjadesPerLimit.incrementAndGet();
                LOG.warning("Limit de " + maximPerIp
                        + " connexions assolit per a " + ip);
                return false;
            }
            if (comptador.compareAndSet(actual, actual + 1)) {
                return true;    // reserva aconseguida
            }
            // compareAndSet ha fallat: un altre fil ha canviat el valor entremig.
            // Es reintenta amb el valor nou. Aixo es 08-06.
        }
    }

    /**
     * Allibera la placa. S'HA de cridar sempre, des d'un finally.
     */
    public void alliberar(Socket connexio) {
        String ip = ipDe(connexio);

        if (eximirBucleInvertit && esBucleInvertit(ip)) {
            return;     // no s'ha reservat, no s'allibera
        }

        // computeIfPresent fa ATOMICAMENT el parell "decrementar i, si
        // arriba a zero, eliminar l'entrada". Retornar null des de la
        // funcio elimina la clau del mapa.
        //
        // Fer-ho en dos passos tindria una cursa classica:
        //     if (comptador.decrementAndGet() == 0) perIp.remove(ip);
        // Entre el decrement i el remove, un altre fil pot incrementar
        // aquest mateix comptador a 1 (una connexio nova de la mateixa IP), i
        // el remove eliminaria un comptador que ja val 1. La connexio
        // nova quedaria comptabilitzada en un objecte orfe i el limit
        // deixaria d'aplicar-se a aquella IP.
        perIp.computeIfPresent(ip, (clau, comptador) -> {
            int queden = comptador.decrementAndGet();
            return queden <= 0 ? null : comptador;   // null elimina l'entrada
        });
    }

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

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

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

    public int ipsConnectades() {
        return perIp.size();
    }
}

// A executar(), despres d'acceptar:
Socket acceptada = servidor.accept();
acceptada.setSoTimeout(limitInactivitatMs);
acceptada.setTcpNoDelay(true);

if (!limitador.admetre(acceptada)) {
    rebutjar(acceptada, "429 MASSA CONNEXIONS");
    continue;       // NO s'ha arribat a delegar al pool: no hi ha res a alliberar
}

try {
    pool.execute(() -> atendreConnexio(acceptada));
} catch (RejectedExecutionException e) {
    // COMPTE: la placa JA estava reservada. Si no s'allibera aqui,
    // es fuga una placa a cada rebuig del pool i la IP acaba
    // bloquejada per sempre.
    limitador.alliberar(acceptada);
    rebutjar(acceptada, "503 SERVIDOR SATURAT");
}

} finally {
    limitador.alliberar(connexio);      // SEMPRE, passi el que passi
    int queden = connexionsActives.decrementAndGet();
    LOG.info(() -> "[" + client + "] desconnectat (" + queden + " actives)");
}

package com.nexussoftware.bibliotech.xarxa;

import com.nexussoftware.bibliotech.excepcio.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;

/**
 * Prova de carrega del ServidorCataleg fent servir el ClientCataleg de 09-02.
 * Mesura latencies, taxa d'error i peticions per segon.
 */
public class ProvaCarrega {

    private static final String[] ISBNS = {
            "978-0000000001",
            "978-0000000002",
            "978-0000000003",
            "000-0000000000"    // inexistent a proposit: ha de donar 404, no error
    };

    private final String host;
    private final int port;

    private final AtomicInteger correctes = new AtomicInteger();
    private final AtomicInteger errors = new AtomicInteger();
    private final AtomicInteger connexionsFallides = new AtomicInteger();
    private final AtomicLong indexLatencies = new AtomicLong();

    /** Latencies en microsegons. Array preassignat: sense sincronitzacio en escriure. */
    private long[] latencies;

    public ProvaCarrega(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void executar(int clients, int peticionsPerClient) throws InterruptedException {
        latencies = new long[clients * peticionsPerClient];

        // Pool per als clients de la prova, amb fils anomenats.
        ExecutorService pool = Executors.newFixedThreadPool(clients, r -> {
            Thread f = new Thread(r);
            f.setName("carrega-" + f.getId());
            return f;
        });

        // Dos latches: un perque TOTS arrenquin alhora (carrega real,
        // no una rampa), i un altre per esperar que TOTS acabin (08-05).
        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch arribada = new CountDownLatch(clients);

        for (int i = 0; i < clients; i++) {
            final int id = i;
            pool.execute(() -> {
                try {
                    sortida.await();    // tots esperen aqui el tret de sortida
                    treballar(id, peticionsPerClient);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    arribada.countDown();
                }
            });
        }

        System.out.printf("Llancant %d clients x %d peticions = %d peticions%n%n",
                clients, peticionsPerClient, clients * peticionsPerClient);

        long t0 = System.nanoTime();
        sortida.countDown();                    // ja!
        arribada.await();                       // esperem tothom
        long duracioNs = System.nanoTime() - t0;

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

        informe(duracioNs);
    }

    private void treballar(int id, int peticions) {
        // Cada client obre la seva propia connexio: ClientCataleg NO es
        // segur per a diversos fils, i a mes aixi mesurem connexions reals.
        try (ClientCataleg client = new ClientCataleg(host, port)) {
            client.connectar();

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

                long t0 = System.nanoTime();
                try {
                    client.consultar(isbn);     // null (404) tambe es exit
                    long us = (System.nanoTime() - t0) / 1000;

                    // Cada fil escriu a la seva propia posicio de l'array:
                    // sense collisions, sense sincronitzacio. L'index es
                    // reparteix amb un comptador atomic.
                    int pos = (int) indexLatencies.getAndIncrement();
                    if (pos < latencies.length) {
                        latencies[pos] = us;
                    }
                    correctes.incrementAndGet();

                } catch (BiblioTechException e) {
                    errors.incrementAndGet();
                }
            }
        } catch (BiblioTechException e) {
            // No s'ha pogut ni connectar: es compta a part, perque significa
            // una altra cosa (saturacio) que un error en una peticio.
            connexionsFallides.incrementAndGet();
        }
    }

    private void informe(long duracioNs) {
        int fetes = (int) Math.min(indexLatencies.get(), latencies.length);
        if (fetes == 0) {
            System.out.println("No s'ha completat cap peticio.");
            System.out.println("Connexions fallides: " + connexionsFallides.get());
            return;
        }

        long[] ordenades = Arrays.copyOf(latencies, fetes);
        Arrays.sort(ordenades);     // 05-09: ordenacio per als percentils

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

        double segons = duracioNs / 1_000_000_000.0;
        double perSegon = correctes.get() / segons;

        System.out.println("=== RESULTAT DE LA PROVA DE CARREGA ===");
        System.out.printf("%-26s %.2f s%n", "Duracio total", segons);
        System.out.printf("%-26s %d%n", "Peticions correctes", correctes.get());
        System.out.printf("%-26s %d%n", "Peticions amb error", errors.get());
        System.out.printf("%-26s %d%n", "Connexions fallides", connexionsFallides.get());
        System.out.printf("%-26s %.0f%n", "Peticions per segon", perSegon);
        System.out.println();
        System.out.println("--- LATENCIES (ms) ---");
        System.out.printf("%-26s %.3f%n", "Minima", ordenades[0] / 1000.0);
        System.out.printf("%-26s %.3f%n", "Mitjana", (suma / (double) fetes) / 1000.0);
        System.out.printf("%-26s %.3f%n", "Mediana (p50)", percentil(ordenades, 50) / 1000.0);
        System.out.printf("%-26s %.3f%n", "p95", percentil(ordenades, 95) / 1000.0);
        System.out.printf("%-26s %.3f%n", "p99", percentil(ordenades, 99) / 1000.0);
        System.out.printf("%-26s %.3f%n", "Maxima",
                ordenades[ordenades.length - 1] / 1000.0);
    }

    private long percentil(long[] ordenades, int p) {
        // Index del percentil sobre l'array ja ordenat.
        int index = (int) Math.ceil(p / 100.0 * ordenades.length) - 1;
        return ordenades[Math.max(0, Math.min(index, ordenades.length - 1))];
    }

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

        for (int clients : new int[]{4, 16, 64}) {
            System.out.println("############ " + clients + " CLIENTS ############");
            new ProvaCarrega(host, port).executar(clients, 200);
            System.out.println();
            Thread.sleep(1000);     // marge perque el servidor es recuperi
        }
    }
}

############ 4 CLIENTS ############
Llancant 4 clients x 200 peticions = 800 peticions

=== RESULTAT DE LA PROVA DE CARREGA ===
Duracio total              0,42 s
Peticions correctes        800
Peticions amb error        0
Connexions fallides        0
Peticions per segon        1897

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

############ 16 CLIENTS ############
Peticions per segon        6104
Mediana (p50)              0,224
p95                        0,668
p99                        1,942
Maxima                     11,208

############ 64 CLIENTS ############
Connexions fallides        0
Peticions per segon        6438
Mediana (p50)              1,102
p95                        4,873
p99                        12,441
Maxima                     58,306