FILS Bank Process

La plantilla del profe: dos programas en uno

El proyecto tiene dos paquetes que no se llaman entre sí. Cada uno es un ejercicio distinto sobre procesos. Lo único que comparten es el formato de las líneas del extracto.

Cada línea del extracto tiene 4 columnas separadas por |. StatementFilter depende de ese orden: 0 fecha, 1 operación, 2 concepto, 3 importe.

2025-01-04 11:32:15 | WITHDRAW  | SUPERMERCAT          |    -120.00 €

Varios procesos, un solo fichero

Cada entidad (el titular, la empresa que paga la nómina…) ejecuta su propio BankProcess. Si lanzas el programa 3 veces, tienes 3 procesos independientes, cada uno con su memoria y su consola. Lo único que comparten es statement.txt en el disco, y por eso hay que coordinar quién escribe.

statement.txt

Un lavabo. Solo cabe una persona.

BankProcess

Cada persona que quiere entrar. Lanzar el programa otra vez es otra persona.

FileLock

La única llave. Quien la tiene entra; los demás esperan en la puerta.

AccountMonitor

El que gestiona la llave. Es el único sitio del código que toca el fichero.

Quién hace qué

El método bueno: AccountMonitor.writeOperation

public void writeOperation(Operation operation, String concept, double amount) {
    String fecha     = LocalDateTime.now().format(FORMATTER);
    String operacion = operation.toString();
    String signo     = operation.sign();
    String importe   = String.format(Locale.ROOT, "%.2f", amount);

    String linea = fecha + " | " + operacion + " | " + concept + " | " + signo + importe + " €\n";

    try (FileOutputStream fos = new FileOutputStream(fileName, true);   // true = añadir al final
         FileLock lock = fos.getChannel().lock()) {               // 🔒 si otro lo tiene, espera aquí
        fos.write(linea.getBytes(StandardCharsets.UTF_8));
    } catch (IOException e) {
        System.err.println("Error: " + e.getMessage());
    }
    // 🔓 al salir del try se libera el lock solo
}

El main de BankProcess

public static void main(String[] args) {
    AccountMonitor monitor = new AccountMonitor(STATEMENT_FILE);
    long pid = ProcessHandle.current().pid();          // cada proceso tiene su PID
    System.out.println("Bienvenido a la oficina " + pid);

    boolean seguir = true;
    while (seguir) {
        Operation operation = ProcessInputUtils.readOperationMenu();
        if (operation == null) break;                // ha elegido 0 y confirmado

        String concept = ProcessInputUtils.readConcept();
        double amount  = ProcessInputUtils.readAmount();

        monitor.writeOperation(operation, concept, amount);   // aquí entra en juego el lock

        seguir = ProcessInputUtils.confirmAnotherOperation();
    }
    System.out.println("Bank process finished.");
}

Lo que verás en el debugger

Breakpoint en fos.write(...). Lanzas A y B con Debug As, uno después del otro.

Con writeOperationSinLock los dos se paran a la vez en el breakpoint, porque nadie bloquea a nadie. Alternando F8 entre A y B ves las letras mezclarse en el fichero.

12 tuberías de procesos en paralelo

BankFilter hace desde Java lo mismo que esta línea de terminal, pero para los 12 meses a la vez:

cat statement-01.txt | java StatementFilter amount -gt 100 | java StatementFilter amount -lt 200 >> filter.txt

Cada filtro es un proceso nuevo (un java que ejecuta StatementFilter). 2 filtros × 12 meses = 24 procesos funcionando a la vez. Entre 100 y 200 € solo quedan los movimientos de SUPERMERCAT (120 €).

Las piezas, una a una

El código final de BankFilter

public static void main(String[] args) throws IOException {
    new File(OUTPUT_FILE).delete();                      // 0. empezar con filter.txt limpio
    List<Process> lastPipelineProcesses = new ArrayList<>();

    for (int month = 1; month <= MONTHS; month++) {    // 1. un pipeline por mes
        String fileName = String.format("%s%02d%s", STATEMENT_PREFIX, month, STATEMENT_SUFFIX);

        List<ProcessBuilder> pipelineProcessBuilders = new ArrayList<>();
        for (String[] command : PIPE_LINE) {             // 2. un builder por filtro
            ProcessBuilder pb = new ProcessBuilder(command);
            pb.redirectError(ProcessBuilder.Redirect.INHERIT);
            pipelineProcessBuilders.add(pb);
        }

        pipelineProcessBuilders.get(0).redirectInput(new File("bank", fileName));   // 3. el primero lee el mes

        List<Process> pipelineProcesses = ProcessBuilder.startPipeline(pipelineProcessBuilders);   // 4. arrancar, SIN esperar

        Process lastPipelineProcess = pipelineProcesses.get(pipelineProcesses.size() - 1);       // 5. guardar el último
        lastPipelineProcesses.add(lastPipelineProcess);
    }

    try (FileOutputStream fos = new FileOutputStream(OUTPUT_FILE, true)) {   // 6. recoger en orden
        for (Process p : lastPipelineProcesses) {
            p.getInputStream().transferTo(fos);
        }
    }
    System.exit(0);
}

La regla del paralelismo: dentro del bucle solo se arranca. Ni waitFor() ni lecturas ahí. Si leyeras dentro, febrero no empezaría hasta que acabara enero.

Por qué sobraba pb.directory(new File("bin"))

Hay dos «carpetas actuales» distintas. La real, donde arranca el proceso (la decide pb.directory). Y user.dir, la que Java cree que es la suya, desde donde busca las clases. El profe ya puso -Duser.dir=bin en los comandos, y es relativo a la carpeta real.

El redirectInput no se ve afectado: esa ruta la resuelve el proceso padre, que se ejecuta en la raíz del proyecto. Por eso new File("bank", fileName) apunta a …/bank/bank/statement-01.txt, que es la ruta que viste en Properties → Location.

Errores que hemos resuelto

Quiz