dining philosopher java alternative solution

Question

I found on a book this alternative solution for "Dining philosopher problem", in 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;
}
}

The text of the solution is:

Alternatively, we can label the chopsticks with a number from e to N - 1. Each philosopher attempts to pick up the lower numbered chopstick first. This essentially means that each philosopher goes for the left chopstick before right one (assuming that's the way you labeled it), except for the last philosopher who does this in reverse. With this solution, a philosopher can never hold the larger chopstick without holding the smaller one. This prevents the ability to have a cycle, since a cycle means that a higher chopstick would "point"to a lower one.

But it's not clear for me. Someone can help me with an example?

Thanks

----EDIT-----

Main class:

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

}

I guess this example is related to the thread starvation. But you could share code how Chopstick instances are shared between Philosopher instances. — Rob, Aug 23 '18 at 12:28

score 1 · Answer 1 · answered Aug 23 '18 at 12:56

Let's have 3 philosophers - p1,p2,p3 and 3 chopsticks c1,c2,c3 (index of chopstick is equal to number)

you create then p1(c1, c2), p2(c2, c3), p3(c1, c3)

worst case scenario:

p1 acquires lock on c1
meanwhile p2 acquires lock on c2 -> blocks p1
p3 is blocked by p1(still holding c1 lock) -> p2 is free to acquire c3
p2 acquires c3 -> finishes and releases c2 and c3
p1 acquires c2 -> finishes and releases c1 and c2
p3 acquires c1 and c3 -> finishes and releases c1 and c3

dining philosopher java alternative solution

1 Answers1