餐飲哲學家使用信號燈

Question

我正在尋找一種方法來解決使用信號量的哲學家哲學問題，我很困擾我該怎麼去做。我已經在下面包含了我的代碼。

class ChopStick{ 
    private int count; 
    private boolean inuse; 
    Lock lock = new ReentrantLock(); 
    Condition notInUse = lock.newCondition(); 

    public ChopStick(){ 
     inuse = false; 
    } 

    public void pickUp(){ 
     lock.lock(); 
     try{ 
      while(inuse){ 
       try{ 
        notInUse.await(); 
       }catch(InterruptedException e){} 
      } 
      inuse = true; 
     }finally{lock.unlock();} 
    } 

    public void putDown(){ 
     lock.lock(); 
     try{ 
      inuse = false; 
      notInUse.signal(); 
     }finally{lock.unlock();} 
    } 
} 

class Philosopher extends Thread{ 
    Semaphore sem; 
    private ChopStick ch1,ch2; //chopsticks 
    private int phil; //philosopher id 

    public Philosopher(int p, ChopStick left, ChopStick right, Semaphore s){ 
     phil = p; 
     ch1 = left; 
     ch2 = right; 
     sem = s; 
    } 

    public void run() { 
     while(true){ 
      try { 
       sem.acquire(); 
      } catch (InterruptedException e) {} 
       think(phil); 
       //pickup chopsticks 
       ch1.pickUp(); 
       ch2.pickUp(); 
       eat(phil); 
       //putdown chopsticks 
       ch1.putDown(); 
       ch2.putDown(); 
       sem.release(); 
      } 
     } 

我在想，當一個哲學家拿起使用sem.acquire()一根筷子，然後當他們使用sem.release()完成，但我不知道這是否是正確的。是嗎？

編輯所以我已經實現了這一點。它似乎工作，但我不知道。

class ChopStick{ 
    private Semaphore sem; 
    public ChopStick(Semaphore s){ 
      sem = s; 
    } 

    public void pickUp(){ 
      try{ 
        sem.acquire(); 
      }catch(InterruptedException e){} 
    } 
    public void putDown(){ 
      sem.release(); 
    } 

Answer 1

而不是將一個信號量上Philosopher，我建議把對Chopstick一個信號; Philosopher要求獲得左右筷子的信號量，並在完成時釋放筷子的信號量。這將取代Chopstick上的ReentrantLock。

爲防止死鎖，您可以使用tryAcquire(int permits, long timeout, TimeUnit unit)，以便Philosopher釋放其左筷子的信號量，如果在超時時間內未能獲得其右筷子的信號量;如果您使用隨機超時（例如100到500毫秒），則每個Philosopher最終都應該取得進展。

編輯：您的新Chopstick代碼運行死鎖的風險 - 所有的哲學家拿起筷子左邊，然後等待永遠爲他們的權利筷子是自由的。一個tryAcquire將允許哲學家釋放它的左筷子，如果它在超時後不能獲得它的右筷子，這將允許哲學家在左邊繼續。

class ChopStick{ 
    private static Random random = new Random(); 

    // initialize with one permit 
    private Semaphore sem = new Semaphore(1); 

    public boolean pickUp(){ 
    try { 
     // wait between 100 and 500 milliseconds 
     return sem.tryAcquire(1, random.nextInt(400) + 100, TimeUnit.MILLISECONDS); 
    } catch(InterruptedException e) { 
     return false; 
    } 
    } 

    public void putDown(){ 
    sem.release(); 
    } 
} 

class Philosopher extends Thread { 
    public void run() { 
    while(true){ 
     think(phil); 
     doEat(); 
    } 

    private void doEat() { 
    if(ch1.pickup()) { 
     if(ch2.pickup()) { 
     eat(phil); 
     ch1.release(); 
     ch2.release(); 
     else { 
     ch1.release(); 
     doEat(); 
     } 
    else { 
     doEat(); 
    } 
    } 
}