la cena de los filosofos

La cena de los filósofos es un problema típico en programación de sincronización de procesos.
El enunciado es el siguiente:
Cinco filósofos alrededor de una mesa pasan su vida comiendo o pensando. Cada filósofo tiene un plato de arroz y un palillo a la izquierda de su plato. Cuando un filósofo quiere comer, cogerá los dos palillos de cada lado del plato y comerá. 
El problema es desarrollarel algoritmo que permita comer a los filósofos. Este algoritmo debe satisfacer la exclusión mutua (dos filósofos no pueden emplear el mismo palillo a la vez), además de evitar el interbloqueo y lainanición.

Wikipedia
Vamos a resolverlo en Java, empleando la clase Semaphore del paquete java.util.concurrent.

 
Creación de la clase Main y la clase Filosofo en Java
En este ejemplo emplearemosel IDE NetBeans.
Comenzamos con la clase Main, la que contendrá el método main()

El proyecto de NetBeans

La clase Main, tal como la crea NetBeans
 
Creamos la clase Filosofo.

Creando una clase

Nombrando la clase

 

 
Código de la clase Main
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
3536
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*
* Pueden estar comiendo 2 filósofos a la vez:
* El filósofo 0 puede comer con el filósofo 2 o con el 3.
* El filósofo 1 puede comer con el filósofo 3 o con el 4.
* El filósofo 2 puede comer con el filósofo 4 o con el 0.
* El filósofo 3 puede comer con el filósofo 0 o conel 1.
* El filósofo 4 puede comer con el filósofo 1 o con el 2.
*/
package paquete;
 
import java.util.concurrent.Semaphore;
 
/**
* Clase donde reside el método main() que inicia la aplicación
*
* @author netsis.es
*/
public class Main {
 
    /**
     * La cantidad de filósofos
     */
    final static int numeroFilosofos = 5;
 
    /**
     * Array de 2 dimensiones quetiene tantas filas como filósofos. Cada fila
     * es un un array de 2 enteros que representan los 2 palillos del filósofo:
     * el de su izquierda y el de su derecha, por este orden.
     */
    final static int[][] palillosFilosofo = {
        {0, 4}, // filosofo 0
        {1, 0}, // filosofo 1
        {2, 1}, // filosofo 2
        {3, 2}, // filosofo 3
        {4, 3} // filosofo 4    };
 
    /**
     * Array de objetos Semaphore que representan a los palillos. Hay tantos
     * palillos como filósofos.
     */
    final static Semaphore[] palillos_semaforo = new Semaphore[numeroFilosofos];
 
    /**
     * Define los parámetros necesarios para construir hilos de la clase
     * Filósofo. Se crean los 5 filósofos y se inician.
     *
     * @param args thecommand line arguments
     */
    public static void main(String[] args) {
        // Crear semáforos. A cada uno se le da un único permiso:
        for (int i = 0; i < numeroFilosofos; i++) {
            // Sólo 1 permiso porque cada palillo-semaforo solo puede tenerlo un filósofo a la vez.
            palillos_semaforo[i] = new Semaphore(1);
        }
 
        // Crear los objetos detipo Filosofo que extienden Thread, e iniciarlos.
        // Al constructor se le pasa un id, el array de los semaforos
        // y el array de sus 2 palillos:
        for (int idFilosofo = 0; idFilosofo < numeroFilosofos; idFilosofo++) {
            new Filosofo(idFilosofo, palillos_semaforo, palillosFilosofo).start();
        }
    }
}
 
 

 
 
Código de la clase Filosofo
 

1
23
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102...