2º DAM — Resumen Completo + Tipo Examen

🧠 Conceptos clave (salen en el test)

📊 Los 4 Algoritmos de Planificación (salen en papel)

Ejemplo resuelto — FCFS

Procesos: P1 (llega t=0, dura 4), P2 (llega t=1, dura 3), P3 (llega t=2, dura 2)

// FCFS — no expulsivo, orden de llegada
// P1 llega primero → ejecuta completo, luego P2, luego P3
//
// Gantt: |  P1  |  P1  |  P1  |  P1  |  P2  |  P2  |  P2  |  P3  |  P3  |
//        t=0    t=1    t=2    t=3    t=4    t=5    t=6    t=7    t=8    t=9
//
// Tiempo de finalización: P1=4, P2=7, P3=9
// Tiempo de espera:       P1=0, P2=4-1=3, P3=7-2=5
// Espera promedio: (0+3+5)/3 = 2.67 unidadesplanificación

Ejemplo resuelto — SRTF (expulsivo)

// SRTF — expulsivo. Si llega uno más corto, expulsa al actual.
// P1(t=0, dur=4) P2(t=1, dur=3) P3(t=2, dur=2)
//
// t=0: llega P1 (remaining=4) → ejecuta P1
// t=1: llega P2 (remaining=3) → P1 tiene 3 restantes, P2 tiene 3 → EMPATE → sigue P1
// t=2: llega P3 (remaining=2) → P3 es más corto → expulsa a P1 → ejecuta P3
// t=4: P3 termina → P2(rem=3) vs P1(rem=2) → P1 es más corto → ejecuta P1
// t=6: P1 termina → ejecuta P2
// t=9: P2 termina
//
// Gantt: |P1|P1|P3|P3|P1|P1|P2|P2|P2|
//        t=0 t=1 t=2 t=3 t=4 t=5 t=6 t=7 t=8 t=9planificación

🔄 Estados de un proceso (test)

// NUEVO → le das al play. El proceso se crea.
// PREPARADO → está en la cola, esperando que el planificador le asigne CPU.
// EN EJECUCIÓN → el CPU está ejecutando sus instrucciones.
// BLOQUEADO → espera E/S (leer fichero, entrada teclado...). Vuelve a PREPARADO cuando termina.
// TERMINADO → el proceso ha acabado. Libera recursos.
//
//  [NUEVO] → [PREPARADO] ⇄ [EN EJECUCIÓN] → [TERMINADO]
//                 ↑              ↓
//                 └──── [BLOQUEADO] ←────teoría

🧵 Las dos formas de crear hilos

① Hilos con implements Runnable

// ─── Clase Galgo (el hilo) ───
public class Galgo implements Runnable {

    private String nombre;
    private int    tiempoCarrera;   // tiempo propio de cada galgo

    // Variable ESTÁTICA = compartida por TODOS los galgos
    private static int tiempoTotalCarrera = 0;
    private static int posicion = 1;

    public Galgo(String nombre, int tiempoCarrera) {
        this.nombre        = nombre;
        this.tiempoCarrera = tiempoCarrera;
    }

    // El método run() es el "main" del hilo. Se ejecuta al llamar start().
    @Override
    public void run() {
        System.out.println(nombre + " empieza a correr...");
        try {
            Thread.sleep(tiempoCarrera);   // simula tiempo corriendo
        } catch (InterruptedException e) {
            System.out.println(nombre + " fue interrumpido");
        }
        System.out.println(nombre + " llega en posición " + posicion++);
    }
}

// ─── Clase Principal (el main) ───
public class Principal {
    public static void main(String[] args) {
        Random rnd = new Random();
        String[] nombres = {"Rayo", "Trueno", "Furia", "Viento"};

        // Con Runnable: envuelvo el objeto en Thread para lanzarlo
        Thread[] hilos = new Thread[nombres.length];

        for (int i = 0; i < nombres.length; i++) {
            Galgo galgo = new Galgo(nombres[i], rnd.nextInt(2000) + 1000);
            hilos[i] = new Thread(galgo);  // envuelvo el Runnable
            hilos[i].start();               // IMPORTANTE: start() no run()
        }

        // join() espera a que todos terminen antes de continuar
        for (Thread h : hilos) {
            try { h.join(); }
            catch (InterruptedException e) { e.printStackTrace(); }
        }

        System.out.println("¡Carrera terminada! Todos los galgos han llegado.");
    }
}java

② Hilos con extends Thread

// ─── Clase Raton — hereda de Thread directamente ───
public class Raton extends Thread {

    private String nombre;
    private int    tiempoComiendo;

    public Raton(String nombre, int tiempoComiendo) {
        this.nombre        = nombre;
        this.tiempoComiendo = tiempoComiendo;
    }

    @Override
    public void run() {
        System.out.printf("%s empieza a comer%n", nombre);
        try {
            Thread.sleep(tiempoComiendo);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.printf("%s ha terminado de comer%n", nombre);
    }
}

// ─── Main ───
public static void main(String[] args) throws InterruptedException {
    // Con Thread: el propio objeto es el hilo
    Raton r1 = new Raton("Mickey",  1500);
    Raton r2 = new Raton("Stuart",  2000);
    Raton r3 = new Raton("Ratatouille", 800);

    r1.start();   // ← start(), NO run()
    r2.start();   // run() solo llamaría el método secuencialmente
    r3.start();

    r1.join();    // espera a que r1 termine
    r2.join();
    r3.join();
    System.out.println("Todos los ratones han comido.");
}java

📊 Variables estáticas — compartidas entre todos los hilos

public class Donante implements Runnable {

    private String nombre;
    private double cantidad;         // PROPIA de cada donante

    // STATIC = hay UNA SOLA copia compartida por todos los donantes
    private static double totalRecaudado = 0.0;

    public Donante(String nombre, double cantidad) {
        this.nombre   = nombre;
        this.cantidad = cantidad;
    }

    @Override
    public void run() {
        System.out.println(nombre + " dona " + cantidad + "€");
        try { Thread.sleep(500); }
        catch (InterruptedException e) { }

        totalRecaudado += cantidad;   // afecta a TODOS
        System.out.println(nombre + " → Total acumulado: " + totalRecaudado + "€");
    }

    public static double getTotalRecaudado() { return totalRecaudado; }
}

// En el main:
public static void main(String[] args) throws InterruptedException {
    ArrayList<Thread> hilos = new ArrayList<>();

    String[]  nombres    = {"Ana", "Luis", "María", "Pedro"};
    double[]  cantidades = {100, 250, 75, 300};

    for (int i = 0; i < nombres.length; i++) {
        Thread h = new Thread(new Donante(nombres[i], cantidades[i]));
        hilos.add(h);
        h.start();
    }

    for (Thread h : hilos) h.join();   // espera a todos antes de mostrar el total

    System.out.println("=== TOTAL DONADO: " + Donante.getTotalRecaudado() + "€ ===");
}java

🔗 ¿Para qué sirve join()?

join() detiene el hilo que lo llama hasta que el hilo llamado termine su ejecución. Se usa para esperar a que todos los hilos terminen ANTES de mostrar resultados totales.

// Sin join() → peligroso: puedes mostrar el total antes de que terminen todos
hilo1.start();
hilo2.start();
hilo3.start();
System.out.println("Total: " + total);  // ← se ejecuta ANTES de que terminen los hilos!

// Con join() → correcto: espera a TODOS antes de mostrar el total
hilo1.start();
hilo2.start();
hilo3.start();
hilo1.join();  // espera a hilo1
hilo2.join();  // espera a hilo2
hilo3.join();  // espera a hilo3
System.out.println("Total: " + total);  // ← ahora sí es el total realjava

📋 ArrayList de hilos (cuando no sabes cuántos habrá)

Cuando el número de hilos es dinámico (lo decide el usuario), usa un ArrayList para guardarlos y luego hacer join() a todos.

public static void main(String[] args) throws InterruptedException {
    Scanner sc = new Scanner(System.in);
    System.out.print("¿Cuántos clientes entran hoy? ");
    int numClientes = sc.nextInt();

    // No puedo escribir 'cliente1.join(), cliente2.join()...' porque no sé cuántos hay
    ArrayList<Thread> hilos = new ArrayList<>();

    // Fase 1: crear y arrancar todos los hilos
    for (int i = 1; i <= numClientes; i++) {
        Thread hilo = new Thread(new Supermercado(i));
        hilos.add(hilo);   // guardo referencia para el join
        hilo.start();
    }

    // Fase 2: esperar a que terminen TODOS
    for (Thread h : hilos) {
        h.join();           // espera a cada uno
    }

    // Fase 3: mostrar resultados SOLO cuando todos han terminado
    System.out.println("=== CAJA 1: " + Supermercado.caja1 + "€");
    System.out.println("=== CAJA 2: " + Supermercado.caja2 + "€");
    System.out.println("=== TOTAL:  " + (Supermercado.caja1 + Supermercado.caja2) + "€");
}java

🏗️ Estructura completa recomendada — Supermercado con 3 cajas

// ─── Supermercado.java ─── (el hilo)
public class Supermercado implements Runnable {

    private int idCliente;

    // Variables estáticas: recaudación de cada caja (compartidas)
    static double caja1 = 0, caja2 = 0, caja3 = 0;

    public Supermercado(int id) { this.idCliente = id; }

    @Override
    public void run() {
        Random rnd = new Random();
        int    cajaElegida = rnd.nextInt(3) + 1;  // caja 1, 2 o 3 aleatoria
        double compra      = rnd.nextDouble() * 100;

        System.out.printf("Cliente %d va a la caja %d (%.2f€)%n", idCliente, cajaElegida, compra);

        try { Thread.sleep(500); }  // simula tiempo en caja
        catch (InterruptedException e) {}

        switch (cajaElegida) {
            case 1: caja1 += compra; break;
            case 2: caja2 += compra; break;
            case 3: caja3 += compra; break;
        }
        System.out.printf("Cliente %d sale de la caja %d%n", idCliente, cajaElegida);
    }
}java

🚦 ¿Qué es un semáforo?

Un semáforo controla cuántos hilos pueden acceder simultáneamente a una sección crítica. Es como un torniquete con N permisos.

• acquire() → pide un permiso. Si hay disponible, pasa. Si no, espera bloqueado.
• release() → devuelve un permiso. Desbloquea al siguiente hilo en espera.
• new Semaphore(N) → semáforo con N permisos simultáneos.
• new Semaphore(1) → exclusión mutua (solo 1 hilo a la vez, igual que un mutex).

🏪 Ejemplo completo — Supermercado con semáforos

import java.util.concurrent.Semaphore;
import java.util.Random;
import java.util.ArrayList;

public class Supermercado implements Runnable {

    private int idCliente;

    // Semáforo de la tienda: máximo 15 personas dentro a la vez
    static Semaphore tienda = new Semaphore(15);

    // Semáforos de cada caja: solo 1 cliente a la vez en cada caja
    static Semaphore caja1 = new Semaphore(1);
    static Semaphore caja2 = new Semaphore(1);
    static Semaphore caja3 = new Semaphore(1);

    // Recaudación de cada caja (estática = compartida)
    static double recCaja1 = 0, recCaja2 = 0, recCaja3 = 0;

    public Supermercado(int id) { this.idCliente = id; }

    @Override
    public void run() {
        Random rnd = new Random();
        try {
            // 1. Entrar a la tienda (máx 15 a la vez)
            tienda.acquire();
            System.out.println("Cliente " + idCliente + " entra a la tienda");
            Thread.sleep(1000);   // simula tiempo comprando

            // 2. Elegir caja aleatoriamente (1, 2 o 3)
            int    cajaNum = rnd.nextInt(3) + 1;
            double compra  = rnd.nextDouble() * 100;

            // 3. Entrar en la caja elegida (solo 1 a la vez)
            switch (cajaNum) {
                case 1:
                    caja1.acquire();
                    System.out.printf("Cliente %d paga %.2f€ en caja 1%n", idCliente, compra);
                    Thread.sleep(500);
                    recCaja1 += compra;
                    caja1.release();
                    break;
                case 2:
                    caja2.acquire();
                    System.out.printf("Cliente %d paga %.2f€ en caja 2%n", idCliente, compra);
                    Thread.sleep(500);
                    recCaja2 += compra;
                    caja2.release();
                    break;
                case 3:
                    caja3.acquire();
                    System.out.printf("Cliente %d paga %.2f€ en caja 3%n", idCliente, compra);
                    Thread.sleep(500);
                    recCaja3 += compra;
                    caja3.release();
                    break;
            }

            System.out.println("Cliente " + idCliente + " sale de la tienda");
            tienda.release();   // libera permiso de la tienda

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// ─── Main ───
public static void main(String[] args) throws InterruptedException {
    int numClientes = 30;
    ArrayList<Thread> hilos = new ArrayList<>();

    for (int i = 1; i <= numClientes; i++) {
        Thread h = new Thread(new Supermercado(i));
        hilos.add(h);
        h.start();
    }
    for (Thread h : hilos) h.join();

    System.out.printf("Caja 1: %.2f€ | Caja 2: %.2f€ | Caja 3: %.2f€%n",
        Supermercado.recCaja1, Supermercado.recCaja2, Supermercado.recCaja3);
    System.out.printf("TOTAL: %.2f€%n",
        Supermercado.recCaja1 + Supermercado.recCaja2 + Supermercado.recCaja3);
}java

🔒 ¿Qué es un monitor?

Un monitor es el mecanismo de Java para asegurar que solo un hilo puede ejecutar un método o bloque a la vez. Se implementa con la palabra clave synchronized.

public synchronized void ingresar(double cantidad) {
    saldo += cantidad;
}java

public void operar() {
  // código libre (no bloqueado)
  synchronized (this) {
    saldo += cantidad; // solo esto bloqueado
  }
  // más código libre
}java

🏦 Ejemplo completo — Cuenta bancaria compartida

// ─── Cuenta.java ─── (recurso compartido)
public class Cuenta {

    private String iban;
    private static double saldo = 1000.0;  // saldo compartido

    public Cuenta(String iban) { this.iban = iban; }

    // synchronized: solo 1 hilo puede ingresar a la vez
    public synchronized void ingresar(String usuario, double cantidad)
            throws InterruptedException {
        System.out.println(usuario + " empieza a ingresar " + cantidad + "€");
        Thread.sleep(500);
        saldo += cantidad;
        System.out.printf("%s ingresa %.2f€ → Saldo: %.2f€%n", usuario, cantidad, saldo);
    }

    // synchronized: solo 1 hilo puede retirar a la vez (para evitar saldo negativo)
    public synchronized void retirar(String usuario, double cantidad)
            throws InterruptedException {
        if (cantidad > saldo) {
            System.out.println(usuario + ": saldo insuficiente");
            return;
        }
        System.out.println(usuario + " empieza a retirar " + cantidad + "€");
        Thread.sleep(500);
        saldo -= cantidad;
        System.out.printf("%s retira %.2f€ → Saldo: %.2f€%n", usuario, cantidad, saldo);
    }

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

// ─── Usuario.java ─── (el hilo)
public class Usuario implements Runnable {
    private String  dni, nombre;
    private double  cantidad;
    private boolean ingresa;   // true=ingresa, false=retira
    private Cuenta  cuenta;    // objeto compartido entre todos los usuarios

    public Usuario(String dni, String nombre, double cantidad,
                   boolean ingresa, Cuenta cuenta) {
        this.dni      = dni;
        this.nombre   = nombre;
        this.cantidad = cantidad;
        this.ingresa  = ingresa;
        this.cuenta   = cuenta;
    }

    @Override
    public void run() {
        try {
            if (ingresa) cuenta.ingresar(nombre, cantidad);
            else         cuenta.retirar(nombre, cantidad);
        } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }
}

// ─── Main ───
public static void main(String[] args) throws InterruptedException {
    Cuenta cuentaCompartida = new Cuenta("ES12345678");

    // TODOS comparten el mismo objeto cuenta
    Thread u1 = new Thread(new Usuario("11A", "Ana",   200, true,  cuentaCompartida));
    Thread u2 = new Thread(new Usuario("22B", "Luis",  500, false, cuentaCompartida));
    Thread u3 = new Thread(new Usuario("33C", "María", 300, true,  cuentaCompartida));

    u1.start(); u2.start(); u3.start();
    u1.join();  u2.join();  u3.join();

    System.out.printf("Saldo final: %.2f€%n", Cuenta.getSaldo());
}java

⚙️ wait(), notify() y notifyAll()

Métodos para coordinar hilos dentro de un bloque synchronized. Solo se usan dentro de synchronized.

Ejemplo Productor-Consumidor

// ─── Monitor.java ─── (recurso compartido con la lógica)
public class Monitor {

    private int     elemento = 0;
    private boolean hayElemento = false;

    // Solo puede insertar si NO hay elemento ya (hayElemento=false)
    public synchronized void insertar(int valor) throws InterruptedException {
        while (hayElemento) {
            wait();   // espera a que el consumidor lo quite
        }
        elemento    = valor;
        hayElemento = true;
        System.out.println("PRODUCTOR insertó: " + valor);
        notifyAll();   // avisa al consumidor
    }

    // Solo puede extraer si HAY elemento (hayElemento=true)
    public synchronized int extraer() throws InterruptedException {
        while (!hayElemento) {
            wait();   // espera a que el productor lo ponga
        }
        int valor = elemento;
        hayElemento = false;
        System.out.println("CONSUMIDOR extrajo: " + valor);
        notifyAll();   // avisa al productor
        return valor;
    }
}

// ─── Productor.java ───
public class Productor implements Runnable {
    private Monitor monitor;
    public Productor(Monitor m) { this.monitor = m; }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            try {
                monitor.insertar(i);
                Thread.sleep(300);
            } catch (InterruptedException e) {}
        }
    }
}

// ─── Consumidor.java ───
public class Consumidor implements Runnable {
    private Monitor monitor;
    public Consumidor(Monitor m) { this.monitor = m; }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            try {
                monitor.extraer();
                Thread.sleep(500);
            } catch (InterruptedException e) {}
        }
    }
}

// ─── Main ───
public static void main(String[] args) throws InterruptedException {
    Monitor    m = new Monitor();  // UN SOLO monitor compartido
    Thread prod = new Thread(new Productor(m));
    Thread cons = new Thread(new Consumidor(m));
    prod.start(); cons.start();
    prod.join();  cons.join();
}java

🌐 Protocolos: TCP vs UDP

📡 Servidor TCP — Estructura básica

import java.net.*;
import java.io.*;

public class Servidor {

    private ServerSocket serverSocket;
    private Socket       socket;
    private DataInputStream  entrada;
    private DataOutputStream salida;

    public void arrancar(int puerto) {
        try {
            // 1. Crear el ServerSocket en el puerto indicado
            serverSocket = new ServerSocket();
            serverSocket.bind(new InetSocketAddress("localhost", puerto));
            System.out.println("Servidor esperando en puerto " + puerto + "...");

            // 2. Esperar conexión del cliente (BLOQUEANTE hasta que conecte)
            socket = serverSocket.accept();
            System.out.println("Cliente conectado: " + socket.getInetAddress());

            // 3. Abrir flujos de entrada y salida
            entrada = new DataInputStream(socket.getInputStream());
            salida  = new DataOutputStream(socket.getOutputStream());

            // 4. Recibir un número del cliente y devolver su doble
            int numero  = entrada.readInt();
            System.out.println("Recibido: " + numero);
            salida.writeInt(numero * 2);
            salida.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            parar();
        }
    }

    public void parar() {
        try {
            if (entrada     != null) entrada.close();
            if (salida      != null) salida.close();
            if (socket      != null) socket.close();
            if (serverSocket!= null) serverSocket.close();
        } catch (IOException e) { e.printStackTrace(); }
    }

    public static void main(String[] args) {
        new Servidor().arrancar(5000);
    }
}java

💻 Cliente TCP — Estructura básica

import java.net.*;
import java.io.*;

public class Cliente {

    private Socket          socket;
    private DataInputStream  entrada;
    private DataOutputStream salida;

    public void conectar(String host, int puerto) {
        try {
            // 1. Conectar al servidor
            socket = new Socket(host, puerto);
            System.out.println("Conectado al servidor");

            // 2. Abrir flujos
            entrada = new DataInputStream(socket.getInputStream());
            salida  = new DataOutputStream(socket.getOutputStream());

            // 3. Enviar un número y recibir el resultado
            Scanner sc = new Scanner(System.in);
            System.out.print("Introduce un número: ");
            int num = sc.nextInt();

            salida.writeInt(num);    // envía al servidor
            salida.flush();

            int respuesta = entrada.readInt();  // recibe del servidor
            System.out.println("El doble es: " + respuesta);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (entrada != null) entrada.close();
                if (salida  != null) salida.close();
                if (socket  != null) socket.close();
            } catch (IOException e) { e.printStackTrace(); }
        }
    }

    public static void main(String[] args) {
        new Cliente().conectar("localhost", 5000);
    }
}java

📨 Enviar y recibir Strings (PrintWriter + BufferedReader)

// En el servidor:
BufferedReader entrada = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter    salida  = new PrintWriter(socket.getOutputStream(), true); // true = auto-flush

String mensajeRecibido = entrada.readLine();    // lee hasta '\n'
salida.println("Respuesta del servidor: OK");  // envía con '\n' al final

// En el cliente (igual):
PrintWriter    salida  = new PrintWriter(socket.getOutputStream(), true);
BufferedReader entrada = new BufferedReader(new InputStreamReader(socket.getInputStream()));

salida.println("Hola servidor");
String respuesta = entrada.readLine();
System.out.println("Recibido: " + respuesta);java