Gestión de Procesos

Concurrencia, Hilos, Sincronización y Optimización

Plataformas Tecnológicas - SPEED

¿Qué es la Gestión de Procesos?

La gestión de procesos es fundamental en sistemas operativos y programación concurrente, permitiendo la ejecución de múltiples tareas de forma eficiente y coordinada.

En desarrollo de software, entender los procesos e hilos es crucial para construir aplicaciones escalables y responsivas, desde servidores web hasta aplicaciones móviles.

Dato Clave

Un sistema operativo moderno puede gestionar miles de procesos simultáneamente, asignando recursos de CPU y memoria de manera equitativa mediante algoritmos de scheduling.

Estados de un Proceso

Estados de un proceso
  • Nuevo Creación
  • Listo Esperando CPU
  • En ejecución Usando CPU
  • Espera I/O o recurso
  • Terminado Finalización

Los procesos transicionan entre estos estados durante su ciclo de vida

Modelos de Concurrencia

Comparativa de Modelos

Modelo Ventajas Desventajas Uso Típico
Procesos Aislamiento, seguridad Overhead de creación Aplicaciones independientes
Hilos Más ligeros, comparten memoria Complejidad de sincronización Aplicaciones concurrentes
Eventos Escalabilidad, sin bloqueos Programación compleja Servidores web
Actores Aislamiento, mensajería Overhead de comunicación Sistemas distribuidos
Procesos

Definición: Instancia independiente de un programa en ejecución.

Ejemplo: fork() en Unix

Aislamiento completo

Comunicación costosa (IPC)

// Creación de proceso en C
pid_t pid = fork();
if (pid == 0) {
    // Código del hijo
} else {
    // Código del padre
}
Hilos

Definición: Unidad de ejecución dentro de un proceso.

Ejemplo: pthreads

Comparten memoria

Riesgo de condiciones de carrera

// Creación de hilo en C
pthread_t thread;
pthread_create(&thread, NULL, 
    thread_function, NULL);
Event Loop

Definición: Modelo asíncrono basado en eventos.

Ejemplo: Node.js

Alto rendimiento I/O

CPU intensivo bloquea todo

// Event loop en JavaScript
setTimeout(() => {
    console.log("Evento ejecutado");
}, 1000);
Modelo de Actores

Definición: Entidades independientes que se comunican con mensajes.

Ejemplo: Erlang/Elixir

Escalabilidad distribuida

Overhead de mensajería

// Actor en Elixir
spawn(fn -> 
    receive do
        {:msg, content} -> IO.puts(content)
    end
end)

Sincronización de Procesos

La coordinación entre procesos e hilos es esencial para evitar condiciones de carrera y garantizar consistencia.

Mutex

Propósito: Exclusión mutua para proteger secciones críticas.

// Uso de mutex en C
pthread_mutex_t lock;
pthread_mutex_lock(&lock);
// Sección crítica
pthread_mutex_unlock(&lock);

Características:

  • Solo un hilo puede adquirirlo
  • Puede causar deadlocks si se usa mal

Semáforos

Propósito: Controlar acceso a recursos con contador.

// Semáforo en C
sem_t sem;
sem_init(&sem, 0, 1);
sem_wait(&sem); // Decrementa
sem_post(&sem); // Incrementa

Características:

  • Puede permitir N accesos simultáneos
  • Útil para problemas productor-consumidor

Monitores

Propósito: Abstracción de alto nivel para sincronización.

// Monitor en Java
public synchronized void metodo() {
    // Sección crítica
}

Características:

  • Combina datos y procedimientos
  • Soporte nativo en algunos lenguajes

Canales

Propósito: Comunicación entre procesos/hilos mediante mensajes.

// Canal en Go
ch := make(chan int)
go func() { ch <- 42 }()
valor := <-ch

Características:

  • Sincronización implícita
  • Alternativa a memoria compartida

Problemas Clásicos de Sincronización

Productor-Consumidor

Un productor genera datos y un consumidor los procesa. Coordinar para que no se produzca desbordamiento ni espera innecesaria.

// Solución con semáforos
sem_t empty, full;
sem_init(&empty, 0, BUFFER_SIZE);
sem_init(&full, 0, 0);
Lectores-Escritores

Múltiples lectores pueden acceder simultáneamente, pero los escritores requieren acceso exclusivo.

// Solución con mutex
pthread_mutex_t rw_mutex;
int reader_count = 0;
pthread_mutex_t count_mutex;
Filósofos Cenando

Cinco filósofos comparten cinco tenedores. Cada uno necesita dos tenedores para comer. Evitar deadlock.

// Solución con semáforos
sem_t forks[5];
sem_t mutex; // Para evitar deadlock

Gestión de Procesos en Lenguajes de Programación

Comparativa entre Lenguajes

Cada lenguaje ofrece diferentes abstracciones para manejar concurrencia y paralelismo. 

// Python - Threading (GIL limitación)
import threading
thread = threading.Thread(target=func)
thread.start()

// Java - Hilos nativos
Thread thread = new Thread(() -> {
    // Código del hilo
});
thread.start();

// Go - Goroutines
go func() {
    // Código concurrente
}()

// JavaScript - Event loop
setTimeout(() => {
    // Callback asíncrono
}, 1000);
Rendimiento y Casos de Uso:
  • Go: Goroutines ligeras, ideal para servicios concurrentes
  • Java: Hilos del sistema, buen balance para aplicaciones empresariales
  • Python: Limitado por GIL, mejor para I/O bound que CPU bound
  • JavaScript: Asíncrono por diseño, excelente para operaciones I/O

Problemas Comunes

Los errores en programación concurrente son notoriamente difíciles de depurar y reproducir.

Problema Descripción Solución
Deadlock Procesos bloqueados esperando recursos Órden de adquisición consistente
Race condition Comportamiento depende del timing Sincronización adecuada
Starvation Proceso no obtiene recursos Algoritmos justos
Priority inversion Tarea de baja prioridad bloquea a una de alta Priority inheritance
Herramientas de Depuración:
  • Helgrind (Valgrind): Detección de race conditions
  • ThreadSanitizer: Detector de data races en tiempo de ejecución
  • GDB: Depuración de programas multi-hilo
  • Visual Studio Debugger: Herramientas para depurar hilos

Patrones de Concurrencia

Patrones Fundamentales:
  • Thread Pool Reutilización
  • Reactor Eventos
  • Producer-Consumer Colas
Patrones Avanzados:
  • MapReduce Procesamiento
  • Bulkhead Aislamiento
  • Circuit Breaker Tolerancia
Ejemplo: Thread Pool en Java
// Creación de un ThreadPoolExecutor
ExecutorService executor = Executors.newFixedThreadPool(4);

// Envío de tareas
for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        System.out.println("Tarea ejecutada por " 
            + Thread.currentThread().getName());
    });
}

// Apagado ordenado
executor.shutdown();
executor.awaitTermination(1, TimeUnit.MINUTES);

Los thread pools evitan el overhead de crear y destruir hilos constantemente.

Procesos en Sistemas Distribuidos

Conceptos Clave

Desafíos en Sistemas Distribuidos:
  • Latencia de red y fallos parciales
  • Consistencia vs disponibilidad (Teorema CAP)
  • Coordinación sin reloj global
  • Tolerancia a particiones de red
Patrones Comunes:
  • Leader Election: Seleccionar un coordinador
  • Two-Phase Commit: Transacciones distribuidas
  • Gossip Protocol: Diseminación de información
  • CRDTs: Tipos de datos replicados sin conflicto
Tecnologías:
Docker/Kubernetes
Apache Kafka
Akka
gRPC

Ejemplo: Servicio Distribuido

Arquitectura de Ejemplo:
Arquitectura distribuida
Implementación con gRPC:
// Definición del servicio en .proto
service WorkerService {
    rpc ProcessTask (TaskRequest) returns (TaskResponse);
}

// Implementación en Go
func (s *server) ProcessTask(ctx context.Context, 
    req *pb.TaskRequest) (*pb.TaskResponse, error) {
    
    result := process(req.Data)
    return &pb.TaskResponse{Result: result}, nil
}

// Cliente que balancea carga
func sendTaskToWorker(task Task, workers []string) {
    conn, _ := grpc.Dial(selectWorker(workers))
    client := pb.NewWorkerServiceClient(conn)
    response, _ := client.ProcessTask(context.Background(), 
        &pb.TaskRequest{Data: task.data})
    // Usar response.Result
}
Consideraciones:
  • Timeouts y reintentos para manejar fallos
  • Circuit breakers para evitar cascadas de fallos
  • Metricas y monitoreo de latencia
  • Balanceo de carga entre instancias

Recursos Adicionales

Libros Recomendados

  • "The Art of Multiprocessor Programming"

    Maurice Herlihy - Fundamentos de programación concurrente

  • "Designing Data-Intensive Applications"

    Martin Kleppmann - Sistemas distribuidos en la práctica

  • "Java Concurrency in Practice"

    Brian Goetz - Concurrencia en Java (conceptos aplicables)

Enlaces Útiles

Sistemas Operativos
Gestión de Procesos
3 de 5
Gestión de Memoria