The JAVA program for "Philosopher Problem"

Question

When I learn the book of "Operating Systems (Design and Implementation)"(written by Andrew S.Tanenbaum), I try to write a program for the "Philosopher Problem" . In the book there is a sample of this problem in C language, and I write it in JAVA. The following is my program, I have tested it. It is correct, but maybe it is not the most efficient way to solve the problem. Can you think out a more efficient program in JAVA to solve this problem?
* Philosopher Eating Problem
* @author mubin
* @version 1.0
public class PhilosopherEating {
//Philosophers' number
private final static int PHER_NUM = 20;
//Philosophers' state
private volatile static int[] pherState = new int[PHER_NUM];
//THINKING
private final static int THINKING = 0;
//HUNGRY
private final static int HUNGRY = 1;
//EATING
private final static int EATING = 2;
//Philosophers thread group
public static Philosopher[] philosophers = new Philosopher[PHER_NUM];
//finish indicator
public volatile static boolean finished =false;
//thread lock
public static Object threadLock = new Object();
public PhilosopherEating() {
* Philosopher class
* @author mubin
* @version 1.0
public static class Philosopher extends Thread{
int pherNo ;
public Philosopher(int no){
this.pherNo = no;
public void run(){
while(!PhilosopherEating.finished){
think();
takeForks(this.pherNo);
eat();
putForks(this.pherNo);
* Thinking
private void think(){
System.out.println("Philosopher"+this.pherNo+"is thinking...");
try {
Thread.sleep( (int)(Math.random()*100));
}catch (Exception ex) {
ex.printStackTrace(System.out);
* Eating
private void eat(){
System.out.println("Philosopher"+this.pherNo+"is eating...");
try {
Thread.sleep( (int)(Math.random()*100));
}catch (Exception ex) {
ex.printStackTrace(System.out);
* Take the fork
private void takeForks(int no){
//System.out.println("takeForks:no:"+no);
synchronized (threadLock) {
pherState[no] = HUNGRY;
testPher(no);
* Put down the fork
private void putForks(int no){
//System.out.println("putForks:no:"+no);
synchronized (threadLock) {
pherState[no] = THINKING;
if( pherState[getLeft()]==HUNGRY ){
philosophers[getLeft()].interrupt();
if( pherState[getRight()]==HUNGRY ){
philosophers[getRight()].interrupt();
* Return the NO. of philosopher who is sitting at the left side of this philosopher
* @return the NO. of the left philosopher
private int getLeft(){
int ret = (pherNo-1)<0? PHER_NUM-1 : (pherNo-1);
return ret;
* Return the NO. of philosopher who is sitting at the right side of this philosopher
* @return the NO. of the right philosopher
private int getRight(){
int ret = (pherNo+1)>=PHER_NUM ? 0 :(pherNo+1);
return ret;
private void testPher(int no){
while(true){
if(pherState[no]==HUNGRY
&&pherState[getLeft()]!=EATING
&&pherState[getRight()]!=EATING) {
pherState[no] = EATING;
//Print and check the philosophers' state
printPher(pherState);
return;
}else{
try {
System.out.println(" Philosopher "+this.pherNo+"is waiting a fork");
threadLock.wait();
}catch (java.lang.InterruptedException ex) {
System.out.println(" Philosopher "+this.pherNo+"is interrupted and woken up to take fork");
//when it is interrupted, do nothing. Just let it continue!
}//end of while(true)
* Print and check the philosophers' state.
* To insure there are no two philosophers sit side by side
* are eating at the same time.
private static void printPher(int[] phers){
System.out.print(" philosophers' state��");
for (int i = 0; i < phers.length; i++) {
System.out.print(" "+phers);
System.out.println("");
for (int i = 0; i < phers.length-1; i++) {
if (phers[i]==EATING && phers[i+1]==EATING){
System.err.println(i+" and "+(i+1)+"two of philosophers sitted side by side are eating at the same time!");
if (phers[0]==EATING && phers[PHER_NUM-1]==EATING){
System.err.println("0 and "+PHER_NUM+"two of philosophers sitted side by side are eating at the same time!");
public static void main(String[] args) {
for (int i = 0; i < PHER_NUM; i++) {
PhilosopherEating.pherState[i] = THINKING;
PhilosopherEating aPhilosopherEating = new PhilosopherEating();
for (int i = 0; i < PHER_NUM; i++) {
philosophers[i] = new Philosopher(i);
philosophers[i].start();
try {
Thread.sleep(30000);
catch (InterruptedException ex) {
ex.printStackTrace(System.out);
//End all the threads of philosophers
PhilosopherEating.finished = true;

Answer 1

this problem is about learning how to use threads/synchronise objects etc, the efficiency of the code isn't really an issue, if that's what you mean. As for the efficiency of the solution, it's very hard to tell how efficient it is, but as long as all the philosphers get to eat there's no problem. I haven't really scrutized your code, but I'm not sure that you have a deadlock free solution: as long as it is possible for all the phils to pick up one fork at the same time there's a problem, and it seems from your code that each philosopher will pick up "his" fork. Again, I could be wrong, I haven't really looked. If you haven't come up with a solution, try drawing it on paper and working it out, or if you're lazy a quick google will probably give you the answer, but I'm pretty sure nobody here will :)