使用信号量的哲学家用餐

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