dining philosophers problem

Hvis du må bruge Semaphore til at løse problemet med så er en af de klassiske løsninger:

semaphore fork[5] = {1, 1, 1, 1, 1};  //definere en semaphore for hver gaffel (fork)

process Philosopher[i = 0 to 3] {
  while (true) {
    P(fork[i]); P(fork[i+1]); //tag den venstre gaffel så den højre
    eat();
    V(fork[i]); V(fork[i+1]);  //frigiv gaflerne igen
    think();
  }
}
process Philosopher[4] {
  while (true) {
    P(fork[0]); P(fork[4]); //tag den højre gaffel så den venstre
    eat();
    V(fork[i]); V(fork[i+1]);  //frigiv gaflerne igen
    think();
  }
}

Denne løsning undgår at der opstår et circular wait dvs. en deadlock, ved at lade den sidst philosopher samle sine gafler op i modsat rækkefølge. En alternativ løsning ville være at lade hver anden samle gaflerne op i modsat række følge. Der findes også løsninger der er baserede på monitore, i stedet for semaphore, men de bliver noget mere komplekse, og dem kan jeg ikke huske i hovedet...
Jeg har desværre ikke rigtig nogen gode link på nettet, men jeg bruger selv Foundations of Multithreaded, Parallel, and Distributed Programming som er rimelig fornuftig bog om parallel programering. Den er skrevet af Gregory R. Andrews

Venlig hilsen
Lars

mange tak... tror bare jeg bruger dette ... (er bare til en fremlæggelse... ikke noget som jeg skal programmere... (vil dog gerne have andre svar hvis det er muligt... skal bruge det senere... men tak)

Et andet alternativ er at bruge monitorer (f.eks. understøtter Java ikke brugen af semaphore), men det er realt set den samme løsning. Idet man konstruere en semaphore vha. monitorer, for så der efter at bruger man ovenstående løsning.

En semaphore i Java kunne f.eks. være flg.

public class Semaphore {

    private int s = 0;

    public Semaphore(int s0) {
    if (s0 >= 0)
        s = s0;
    else
        throw new Error("Semaphore initialized to negative value: " + s0);
    }

    public synchronized void P()
    throws InterruptedException {
    while (s == 0) wait();
    s--;
    }

    public synchronized void V() {
    s++;
    notify();
    }
}