⚙️ Procesos e hilos

1 Conceptos básicos

PCB (Process Control Block)

Cada proceso tiene un PCB con lo que el SO necesita para ejecutarlo:

• Código del programa.
• Datos que usa.
• Estado del procesador: registros y el PC (Program Counter).

Qué hace el SO al ejecutar una app

• Carga el ejecutable en memoria.
• Le asigna recursos (CPU, memoria, ficheros…).
• Gestiona su ciclo de vida.

Proceso vs hilo (la diferencia clave)

Ventajas e inconvenientes de los hilos

• ✅ Más eficientes que crear procesos, permiten paralelismo en multinúcleo, compartir datos es fácil, buena respuesta en apps gráficas y en tareas de E/S.
• ❌ Condiciones de carrera, interbloqueos, y un fallo afecta a todo el proceso.

2 Estados de un proceso y planificación

• Nuevo (new): creado pero aún no se ejecuta.
• Preparado (ready): listo, esperando la CPU.
• Ejecución (running): usando la CPU.
• Bloqueado (waiting): esperando un recurso o evento (p. ej. leer un fichero). Cuando llega, vuelve a Preparado.
• Finalizado (terminated): ha acabado.

Planificadores

Hay más procesos que CPUs, así que el planificador decide quién se ejecuta y cuándo.

Algoritmos de planificación

3 Concurrencia, paralelismo y distribución

• Concurrencia: varias tareas ejecutándose "a la vez". No siempre es paralelismo real.
• 1 núcleo (monoprocesador): se alternan muy rápido → multiprogramación.
• Varios núcleos (multiprocesador): paralelismo real → programación paralela.

Objetivos de la concurrencia

• Mejorar el tiempo de respuesta.
• Aprovechar mejor los recursos (mientras uno espera disco, otro usa CPU).
• Modularidad: dividir la app en tareas independientes.

Paralela vs distribuida

Problemas típicos

4 Gestión de procesos e IPC

• PID: identificador único del proceso. PPID: PID del proceso padre.

IPC (Inter-Process Communication)

Cómo se pasan datos los procesos. Técnicas: ficheros y pipes (sencillas), sockets, memoria compartida y colas de mensajes (más potentes).

Sincronización entre procesos

• Bloqueo de ficheros: solo un proceso puede escribir.
• Semáforos: contador que limita cuántos acceden. Binario = 1 (como un candado); contador = N a la vez.
• Colas de mensajes: además de comunicar, coordinan (uno espera el "permiso" del otro).

5 Procesos en Java

Runtime

Process p = Runtime.getRuntime().exec("notepad");  // lanza un proceso externo
p.waitFor();                                      // espera a que acabe

Métodos de Process

ProcessBuilder (el recomendado)

Más control de argumentos, permite redirigir entrada/salida y es más claro.

ProcessBuilder pb = new ProcessBuilder("ls", "-l");   // orden y argumentos separados
pb.redirectOutput(new File("salida.txt"));          // también redirectInput / redirectError
Process p = pb.start();                             // ejecuta

Pipes en Java: conectar la salida de un proceso (ls / dir) a la entrada de otro (grep / findstr). Java lo automatiza con ProcessBuilder.startPipeline(...).

6 Hilos en Java

Todo programa Java empieza con el hilo principal (main thread). Dos formas de crear hilos:

// 1) Heredar de Thread
class MiHilo extends Thread {
    public void run() { System.out.println("Hola desde un hilo"); }
}
new MiHilo().start();

// 2) Implementar Runnable  (⭐ recomendada)
class MiTarea implements Runnable {
    public void run() { System.out.println("Hola"); }
}
new Thread(new MiTarea()).start();

Por qué Runnable es mejor: tu clase puede heredar de otra a la vez (Java no tiene herencia múltiple) y se reutiliza mejor el código.

Control de hilos

Los estados de un hilo están en el enum Thread.State: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED.

7 Sincronización de hilos

• Sección crítica: trozo de código que toca un recurso compartido. Solo un hilo a la vez.
• Exclusión mutua (MUTEX): mecanismo que garantiza eso.
• count++ no es atómico → con varios hilos da resultados erróneos.
• Lectores/escriptores: varios lectores pueden leer a la vez, pero si escribe uno, nadie más debe acceder.

// Método sincronizado: bloquea el objeto entero
public synchronized void incrementar() { count++; }

// Bloque sincronizado: solo bloquea la parte crítica (más eficiente)
public void incrementar() {
    synchronized (this) { count++; }
}

Deadlock y cómo evitarlo

Hilo 1 bloquea cuenta A y quiere B; hilo 2 bloquea cuenta B y quiere A → ninguno avanza.

Solución: establecer un orden global de bloqueo (todos bloquean siempre en el mismo orden, p. ej. por id de cuenta).

8 Comunicación entre hilos: wait() / notify()

No basta con no pisarse: a veces un hilo tiene que avisar a otro (p. ej. "ya hay datos").

• wait(): el hilo se duerme y suelta el lock hasta que le avisen.
• notify(): despierta a un hilo que espera. notifyAll(): a todos.
• Solo se pueden llamar dentro de un bloque synchronized (necesitan el monitor).

synchronized (obj) {
    while (!condicion) {   // ⚠️ while, NO if
        obj.wait();
    }
    // hacer el trabajo
    obj.notifyAll();
}

Productor / Consumidor

• Productores meten datos en un almacén compartido de capacidad limitada; consumidores los sacan.
• Almacén lleno → el productor hace wait().
• Almacén vacío → el consumidor hace wait().
• Cada vez que uno mete o saca algo, hace notify() para despertar al otro.

🎮 Quiz estilo Kahoot