用信号量吃饭

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();
            }
        }

我在想，当一位哲学家用扫描电镜拿起筷子时。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

与其把信号灯放在哲学家的筷子上，我建议把信号灯放在筷子上；哲学家调用获取左右筷子的信号量，并在完成后释放筷子的信号量。这将取代筷子上的可重入锁。

为了防止死锁，您可以使用try Acquire（int许可，长超时，TimeUnit单位），以便如果Philosher在超时内未能获得其右筷子的信号量，则释放其左筷子的信号量；如果您使用随机超时（例如，在100到500毫秒之间），那么每个哲学家最终都应该取得进展。

编辑：你的新筷子代码有死锁的风险-所有哲学家拿起他们的左筷子，然后永远等待他们的右筷子自由。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();
    }
  }
}