Problema de la cena de los filósofos

El problema de la cena de los filósofos o problema de los filósofos cenando (dining philosophers problem) es un problema clásico de las ciencias de la computación propuesto por Edsger Dijkstra en 1965 para representar el problema de la sincronización de procesos en un sistema operativo. Cabe aclarar que la interpretación está basada en pensadores chinos, quienes comían con dos palillos, donde es más lógico que se necesite el del comensal que se siente al lado para poder comer. El problema de los 5 filósofos presenta una situación hipotética donde cinco filósofos se sientan alrededor de una mesa redonda, cada uno con un plato de pasta y un tenedor entre cada par de filósofos adyacentes. La dificultad radica en permitir que cada filósofo alterne entre dos estados, pensamiento y comer, sin que se produzcan bloqueos mutuos mientras intentan adquirir los tenedores adyacentes necesarios para comer.

Enunciado del problema

Cinco filósofos se sientan alrededor de una mesa y pasan su vida cenando y pensando. Cada filósofo tiene un plato de fideos y un tenedor a la izquierda de su plato. Para comer los fideos son necesarios dos tenedores y cada filósofo sólo puede tomar los que están a su izquierda y derecha. Si cualquier filósofo toma un tenedor y el otro está ocupado, se quedará esperando, con el tenedor en la mano, hasta que pueda tomar el otro tenedor, para luego empezar a comer.

Si dos filósofos adyacentes intentan tomar el mismo tenedor a una vez, se produce una condición de carrera: ambos compiten por tomar el mismo tenedor, y uno de ellos se queda sin comer.

Si todos los filósofos toman el tenedor que está a su derecha al mismo tiempo, entonces todos se quedarán esperando eternamente, porque alguien debe liberar el tenedor que les falta. Nadie lo hará porque todos se encuentran en la misma situación (esperando que alguno deje sus tenedores). Entonces los filósofos se morirán de hambre. Este bloqueo mutuo se denomina interbloqueo o deadlock.

El problema consiste en encontrar un algoritmo que permita que los filósofos nunca se mueran de hambre.

Diversas soluciones posibles

La resolución exitosa de este problema implica abordar cuestiones adicionales relacionadas con la comunicación entre nodos, la consistencia de los datos distribuidos y la tolerancia a fallos. Además, requiere el diseño e implementación de algoritmos de sincronización y coordinación que garanticen la coherencia y eficiencia en la ejecución de procesos distribuidos. En este contexto, la comprensión profunda de los principios de concurrencia y coordinación es esencial para la construcción y el mantenimiento de sistemas distribuidos robustos y eficientes.

Por turno cíclico

Se empieza por un filósofo, que si quiere puede comer y después pasa su turno al de la derecha. Cada filósofo sólo puede comer en su turno. Problema: si el número de filósofos es muy alto, uno puede morir de hambre antes de su turno.

Varios turnos

Se establecen varios turnos. Para hacerlo más claro supongamos que cada filósofo que puede comer (es su turno) tiene una ficha que después pasa a la derecha. Si por ejemplo hay 7 comensales podemos poner 3 fichas en posiciones alternas (entre dos de las fichas quedarían dos filósofos).

Se establecen turnos de tiempo fijo. Por ejemplo cada 5 minutos se pasan las fichas (y los turnos) a la derecha.

Con base al tiempo que suelen tardar los filósofos en comer y en volver a tener hambre, el tiempo de turno establecido puede hacer que sea peor solución que la anterior. Si el tiempo de turno se aproxima al tiempo medio que tarda un filósofo en comer esta variante da muy buenos resultados. Si además el tiempo medio de comer es similar al tiempo medio en volver a tener hambre la solución se aproxima al óptimo.

Colas de tenedores

Cuando un filósofo quiere comer se pone en la cola de los dos tenedores que necesita. Cuando un tenedor está libre lo toma. Cuando toma los dos tenedores, come y deja libre los tenedores.

Visto desde el otro lado, cada tenedor sólo puede tener dos filósofos en cola, siempre los mismos.

Esto crea el problema comentado de que si todos quieren comer a la vez y todos empiezan tomando el tenedor de su derecha se bloquea el sistema (deadlock).

Resolución de conflictos en colas de tenedores

Cada vez que un filósofo tiene un tenedor espera un tiempo aleatorio para conseguir el segundo tenedor. Si en ese tiempo no queda libre el segundo tenedor, suelta el que tiene y vuelve a ponerse en cola para sus dos tenedores.

Si un filósofo A suelta un tenedor (porque ha comido o porque ha esperado demasiado tiempo con el tenedor en la mano) pero todavía desea comer, vuelve a ponerse en cola para ese tenedor. Si el filósofo adyacente B está ya en esa cola de tenedor (tiene hambre) lo toma y si no vuelve a cogerlo A.

Es importante que el tiempo de espera sea aleatorio o se mantendrá el bloqueo del sistema.

El portero del comedor

Se indica a los filósofos que abandonen la mesa cuando no tengan hambre y que no regresen a ella hasta que vuelvan a estar hambrientos (cada filósofo siempre se sienta en la misma silla). La misión del portero es controlar el número de filósofos en la sala, limitando su número a n-1, pues si hay n-1 comensales seguro que al menos uno puede comer con los dos tenedores.

Pseudocódigo

int tenedores[5];

int estado_filosofos[5];

void cambiar_estado(int filosofo, int nuevo_estado) {
    estado_filosofos[filosofo] = nuevo_estado;
}

int estado_izquierdo(int filosofo) {
    return estado_filosofos[(filosofo + 4) % 5];
}

int estado_derecho(int filosofo) {
    return estado_filosofos[(filosofo + 1) % 5];
}

void intentar_comer(int filosofo) {
    if (estado_filosofos[filosofo] == 1 && estado_izquierdo(filosofo) != 2 && estado_derecho(filosofo) != 2) {
        cambiar_estado(filosofo, 2);
        tomar_tenedores(filosofo);
    }
}

void dejar_comer(int filosofo) {
    cambiar_estado(filosofo, 0);
    dejar_tenedores(filosofo);
    intentar_comer((filosofo + 4) % 5);
    intentar_comer((filosofo + 1) % 5);
}

void filosofo(int id) {
    while (true) {
        pensar();
        cambiar_estado(id, 1);
        intentar_comer(id);
        esperar();
        dejar_comer(id);
    }
}

Aplicaciones en Sistemas Distribuidos y Embebidos

El problema de la cena de los filósofos tiene aplicaciones prácticas en una amplia gama de sistemas distribuidos y embebidos, donde la correcta gestión de los recursos garantiza tanto la coherencia de los datos como el funcionamiento adecuado del sistema. En un sistema embebido, por ejemplo, como los utilizados en automóviles o electrodomésticos, los sensores actúan como productores, generando datos que son consumidos por un controlador central. Estos sistemas requieren que múltiples procesos se coordinen adecuadamente para acceder a los recursos de manera ordenada y evitar condiciones de carrera. En un entorno distribuido, una interrupción en la coordinación entre nodos o procesos puede afectar la integridad de los datos y el rendimiento general del sistema. Por esta razón, los problemas de sincronización en el problema de los filósofos ayudan a ilustrar y resolver desafíos críticos en la asignación de recursos en sistemas complejos y distribuidos.

Implementación Práctica en Lenguajes de Programación

El problema de los cinco filósofos es un excelente modelo educativo para comprender la programación concurrente y la sincronización de procesos en lenguajes como Java o Python. A través de este problema, los desarrolladores pueden aprender a implementar estructuras de sincronización, como semáforos y mutex, y a gestionar el acceso a los recursos de manera segura y eficiente. En Java, por ejemplo, la clase BlockingQueue facilita la sincronización entre hilos, permitiendo que un proceso espere hasta que haya recursos disponibles sin bloquear el acceso de otros procesos. En Python, el módulo threading proporciona herramientas para implementar concurrencia y exclusión mutua, asegurando que los recursos compartidos sean accesibles sin riesgo de condiciones de carrera. Estos lenguajes permiten simular el problema de los cinco filósofos para observar cómo diferentes soluciones de sincronización afectan la eficiencia y evitan el interbloqueo, aplicando estos conocimientos en el diseño de sistemas embebidos y distribuidos.

Variantes y Extensiones del Problema de los Filósofos

El problema de los cinco filósofos tiene diversas variantes que permiten explorar soluciones más complejas a los desafíos de sincronización y concurrencia en sistemas distribuidos. Por ejemplo:

Añadir un Portero o "Footman": En esta variante, se introduce un portero que permite que solo cuatro filósofos se sienten a la mesa al mismo tiempo. Esta restricción reduce las probabilidades de interbloqueo, ya que siempre hay un filósofo que puede acceder a ambos tenedores, evitando que todos esperen simultáneamente por el tenedor de su vecino. Este enfoque muestra cómo una pequeña restricción en el acceso a los recursos puede mejorar significativamente la eficiencia y seguridad en la concurrencia.
Uso de Temporizadores Aleatorios para Evitar el Interbloqueo: Otra solución consiste en permitir que cada filósofo suelte los tenedores después de esperar un tiempo aleatorio si no puede obtener ambos. Esto simula una espera probabilística que reduce la posibilidad de interbloqueo y se utiliza en sistemas donde los procesos deben ceder los recursos temporalmente si no logran completar su tarea en un período específico. Esta técnica es útil en sistemas distribuidos donde los procesos tienen diferentes prioridades y tiempos de espera.
Modelo de "Pensar-Comer" Cíclico: Esta variante sugiere que cada filósofo alterna entre pensar y comer en un ciclo fijo o programado, de manera que los recursos se distribuyen en intervalos predecibles. Este enfoque se usa en sistemas de tiempo real donde los procesos necesitan sincronizarse en intervalos regulares para evitar el bloqueo y garantizar que todos accedan a los recursos equitativamente. Por ejemplo, en sistemas embebidos de monitoreo de sensores, esta estrategia permite que todos los dispositivos tengan acceso equitativo a la red o a los recursos de procesamiento sin esperar indefinidamente.