Concurrencia y Paralelismo en Sistemas Operativos: Conceptos y Aplicaciones

Conceptos Fundamentales de Concurrencia y Paralelismo

1. ¿Qué es la concurrencia en el contexto de sistemas operativos?
La concurrencia es la capacidad de un sistema operativo para gestionar múltiples tareas que parecen ejecutarse simultáneamente, alternando entre ellas de manera eficiente.

2. ¿Cuáles son las principales diferencias entre concurrencia y paralelismo?

• Concurrencia: Alterna entre tareas en un solo núcleo.
• Paralelismo: Ejecuta tareas simultáneamente en múltiples núcleos.

3. Defina el término hilo en el contexto de sistemas operativos.
Un hilo es la unidad básica de ejecución dentro de un proceso, que comparte los recursos del proceso pero puede ejecutarse de forma independiente.

4. ¿Qué es un proceso en sistemas operativos y en qué se diferencia de un hilo?
Un proceso es un programa en ejecución con su propio espacio de memoria y recursos asignados. Un hilo es una parte de un proceso que comparte su espacio de memoria, siendo más ligero y rápido que un proceso.

5. ¿Cuáles son las ventajas de usar hilos en un programa?

• Reducción del sobrecarga de memoria.
• Mejor utilización de la CPU.
• Comunicación más rápida entre tareas.
• Creación y gestión más económica que los procesos.

Gestión de Recursos y Sincronización

6. Explique cómo los sistemas operativos gestionan los recursos compartidos en un entorno concurrente.
Utilice mecanismos como bloqueos, semáforos, monitores y algoritmos de planificación para garantizar la sincronización y evitar conflictos.

7. ¿Qué es un cambio de contexto?
Es el proceso mediante el cual el sistema operativo guarda el estado de un proceso/hilo y carga el de otro, permitiendo la multitarea.

8. ¿Qué factores afectan el rendimiento de un sistema con múltiples hilos?

• Sobrecarga de sincronización.
• Competencia por recursos compartidos.
• Frecuencia de cambios de contexto.
• Número de núcleos disponibles.
• Equilibrio de carga entre hilos.

Problemas Comunes en la Concurrencia

9. ¿Qué es la condición de carrera?
Es una situación donde el resultado de un programa depende del orden en que se ejecutan hilos/procesos que comparten recursos, causando errores impredecibles.

10. Explique la diferencia entre hilos de usuario e hilos del núcleo.

• Hilos de usuario: Gestionados por el programa; no pueden usar múltiples núcleos.
• Hilos del núcleo: Gestionados por el sistema operativo; permiten usar múltiples núcleos.

11. ¿Qué es un mutex y cómo se usa para sincronizar hilos?
Un mutex (exclusión mutua) es un mecanismo de sincronización que asegura que solo un hilo puede acceder a un recurso compartido a la vez. Se usa bloqueando el mutex antes de acceder al recurso y desbloqueándolo después.

12. Defina el término interbloqueo en sistemas concurrentes.
Un interbloqueo ocurre cuando dos o más hilos o procesos quedan bloqueados indefinidamente porque cada uno espera un recurso que está siendo retenido por otro.

Estrategias para Evitar Interbloqueos

13. Menciona y explica al menos dos estrategias para evitar puntos muertos.

1. Evitación del interbloqueo: Usar un algoritmo como el del banquero para garantizar que los recursos solo se asignen si no causarán un interbloqueo.
2. Ordenación de recursos: Establecer un orden estricto de adquisición de recursos para evitar ciclos en la asignación.

Implementación de la Exclusión Mutua en C++

14. ¿Cómo se puede implementar una exclusión mutua en C++?
Se puede usar la clase std::mutex de la biblioteca estándar:

#include <mutex>
std::mutex mtx;
mtx.lock(); // Bloquea el mutex
// Código que accede a recursos compartidos
mtx.unlock(); // Desbloquea el mutex

O usar std::lock_guard para manejar automáticamente el bloqueo y desbloqueo:

std::lock_guard<std::mutex> guard(mtx);
// Código protegido

Bibliotecas de C++ para el Manejo de Hilos

15. ¿Qué bibliotecas de C++ se utilizan para manejar hilos?

• std::thread: Para crear y gestionar hilos.
• std::mutex: Para sincronización mediante exclusión mutua.
• std::condition_variable: Para la sincronización de hilos basada en eventos.
• std::future y std::promise: Para comunicación entre hilos.

Diferencias entre Condición de Carrera e Interbloqueo

16. ¿Cómo se diferencia una condición de carrera de un interbloqueo?

• Condición de carrera: Problema de concurrencia donde el resultado depende del orden de ejecución de los hilos.
• Interbloqueo: Situación en la que dos o más hilos quedan esperando indefinidamente.

17. ¿Qué son las variables de condición?
Son primitivas que permiten a los hilos esperar hasta que una condición específica sea verdadera. Funcionan junto con un mutex para coordinar el acceso a recursos compartidos.

18. Describe el modelo de memoria y cómo afecta la concurrencia.
(Incompleto en el original, se sugiere completar) El modelo de memoria define cómo los hilos interactúan a través de la memoria compartida. Un modelo de memoria débil puede permitir reordenamientos de instrucciones que afectan la concurrencia, mientras que un modelo de memoria fuerte garantiza un orden más estricto, simplificando la programación concurrente pero potencialmente con un costo de rendimiento.

Técnicas de Diseño para Programas Concurrentes

19. Menciona y explica al menos una técnica de diseño para programas concurrentes.
División de tareas: Dividir el trabajo en tareas independientes que pueden ejecutarse en paralelo, minimizando la necesidad de sincronización entre hilos. Esto reduce la posibilidad de interbloqueos y condiciones de carrera.

Medición del Rendimiento de un Programa Concurrente

20. ¿Cómo se puede medir el rendimiento de un programa concurrente?

• Tiempo de ejecución: Comparar el tiempo total con una implementación secuencial.
• Velocidad de aceleración: Relación entre el tiempo secuencial y paralelo.
• Eficiencia: Relación entre velocidad de aceleración y número de hilos.
• Uso de CPU: Verifique qué tan bien se utilizan los núcleos disponibles.

Ejemplo de Código en C++

#include <iostream>
#include <thread>

// Función que ejecutará cada hilo
void funcionHilo(int id) {
    std::cout << "Soy el hilo " << id << std::endl;
}

int main() {
    // Crear 5 hilos
    std::thread hilo1(funcionHilo, 1);
    std::thread hilo2(funcionHilo, 2);
    std::thread hilo3(funcionHilo, 3);
    std::thread hilo4(funcionHilo, 4);
    std::thread hilo5(funcionHilo, 5);

    // Unir los hilos al hilo principal
    hilo1.join();
    hilo2.join();
    hilo3.join();
    hilo4.join();
    hilo5.join();

    std::cout << "Todos los hilos han terminado." << std::endl;
    return 0;
}