java替代解决方案

Question

我在一本书中发现了一个“用餐哲学家问题”的替代解决方案，用Java编写：

public class Philosopher extends Thread {
private final int maxPause = 100;
private int bites = 10;

private Chopstick lower;
private Chopstick higher;
private int index;
public Philosopher(int i, Chopstick left, Chopstick right) {
    index = i;
    if (left.getNumber() < right.getNumber()) {
        this.lower = left;
        this.higher = right;
    } else {
        this.lower = right;
        this.higher = left;
    }
}

public void eat() {
    System.out.println("Philosopher " + index + ": start eating");
    pickUp();
    chew();
    putDown();
    System.out.println("Philosopher " + index + ": done eating");
}

public void pickUp() {
    pause();
    lower.pickUp();
    pause();
    higher.pickUp();
    pause();
}

public void chew() {
    System.out.println("Philosopher " + index + ": eating");
    pause();
}

public void pause() {
        try {
        int pause = AssortedMethods.randomIntInRange(0, maxPause);
        Thread.sleep(pause);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
   }

public void putDown() {
    higher.putDown();
    lower.putDown();
}

public void run() {
    for (int i = 0; i < bites; i++) {
        eat();
    }
}
}

public class Chopstick {
private Lock lock;
private int number;

public Chopstick(int n) {
    lock = new ReentrantLock();
    this.number = n;
}

public void pickUp() {
    lock.lock();
}

public void putDown() {
    lock.unlock();  
}

public int getNumber() {
    return number;
}
}

解决方案的文本是：

或者，我们可以给筷子贴上从e到N-1的标签。每个哲学家都试图先拿起编号较低的筷子。这基本上意味着每个哲学家都会先选择左边的筷子，再选择右边的筷子（假设你是这样给它贴标签的），除了最后一位哲学家会选择相反的方式。有了这个解决方案，哲学家不可能拿着大筷子而不拿着小筷子。这就阻止了循环的能力，因为循环意味着较高的筷子“指向”较低的筷子。

但我不清楚。有人能帮我举个例子吗？

谢谢

----编辑-----

主要类别：

 public class Question {
public static int size = 3;

public static int leftOf(int i) {
    return i;
}

public static int rightOf(int i) {
    return (i + 1) % size;
}

public static void main(String[] args) {        
    Chopstick[] chopsticks = new Chopstick[size + 1];
    for (int i = 0; i < size + 1; i++) {
        chopsticks[i] = new Chopstick(i);
    }

    Philosopher[] philosophers = new Philosopher[size];
    for (int i = 0; i < size; i++) {
        Chopstick left = chopsticks[leftOf(i)];
        Chopstick right = chopsticks[rightOf(i)];
        philosophers[i] = new Philosopher(i, left, right);
    }

    for (int i = 0; i < size; i++) {
        philosophers[i].start();
    }       
}

}

Answer 1

让我们有三个哲学家——p1、p2、p3和三根筷子c1、c2、c3（筷子的索引等于<代码>数字 ）

然后创建p1（c1，c2）、p2（c2，c3）、p3（c1，c3）

最坏情况：

• p1获取c1上的锁
• 同时p2获得对c2的锁定-