Dinning Philosopher problem

Author: Ashfaqbs

Concurrency_Multithreading_and_Parallel_Computing_in_Java/bin/org/ashfaq/dev/concepts/Concurrent_Collections/CopyOnWriteArraysEg.class

@@ -0,0 +1,50 @@
+package org.ashfaq.dev.problems.DiningPhilosophers;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class App {
+
+	public static void main(String[] args) throws InterruptedException {
+		
+		ExecutorService executorService = null;
+		Philosopher[] philosophers = null;
+		
+		try{
+			
+			philosophers = new Philosopher[Constants.NUM_PHILOSOPHERS];
+			Chopsticks[] chopSticks = new Chopsticks[Constants.NUM_PHILOSOPHERS];
+			
+			for(int i=0;i<Constants.NUM_CHOPSTICKS;i++){
+				chopSticks[i] = new Chopsticks(i);
+			}
+			
+			executorService = Executors.newFixedThreadPool(Constants.NUM_PHILOSOPHERS);
+			
+			for(int i=0;i<Constants.NUM_PHILOSOPHERS;i++){
+				philosophers[i] = new Philosopher(i, chopSticks[i], chopSticks[(i+1) % Constants.NUM_PHILOSOPHERS]);
+				executorService.execute(philosophers[i]);
+			}
+			
+			Thread.sleep(Constants.Simulation_Running_Time);
+			
+			for(Philosopher philosopher : philosophers){
+				philosopher.setFull(true);
+			}		
+		}finally{
+			
+			executorService.shutdown();
+			
+			while(!executorService.isTerminated()){
+				Thread.sleep(1000);
+			}
+			
+			for(Philosopher philosopher : philosophers ){
+				System.out.println(philosopher+" eat #"+philosopher.getEatingCounter());
+			}
+			
+		}
+		
+	}
+}
+

Concurrency_Multithreading_and_Parallel_Computing_in_Java/bin/org/ashfaq/dev/concepts/Concurrent_Collections/ExchangerExample.class

@@ -0,0 +1,40 @@
+package org.ashfaq.dev.problems.DiningPhilosophers;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class Chopsticks {
+
+	private Lock lock;
+	private int id;
+	
+	public Chopsticks(int id){
+		this.id = id;
+		this.lock = new ReentrantLock();
+	}
+	
+	public boolean pickUp(Philosopher philosopher, State state) throws InterruptedException{
+	
+		if( this.lock.tryLock(10, TimeUnit.MILLISECONDS)){
+			System.out.println(philosopher+" picked up "+state.toString()+" "+this);
+			return true;
+		}
+		
+		return false;
+	}
+	
+	public void putDown(Philosopher philosopher, State state) {
+		this.lock.unlock();
+		System.out.println(philosopher+" put down "+this);
+	}
+	
+	@Override
+	public String toString() {
+		return "Chopstick-"+this.id;
+	}
+}

Concurrency_Multithreading_and_Parallel_Computing_in_Java/bin/org/ashfaq/dev/concepts/Concurrent_Collections/FirstThread.class

@@ -0,0 +1,14 @@
+package org.ashfaq.dev.problems.DiningPhilosophers;
+
+public class Constants {
+
+	public static final int NUM_PHILOSOPHERS = 5;
+	public static final int NUM_CHOPSTICKS = 5;
+	public static final int Simulation_Running_Time = 1000;
+	
+	
+	
+
+	private Constants() {
+	}
+}

Concurrency_Multithreading_and_Parallel_Computing_in_Java/bin/org/ashfaq/dev/concepts/Concurrent_Collections/ReaderW.class

@@ -0,0 +1,68 @@
+package org.ashfaq.dev.problems.DiningPhilosophers;
+
+import java.util.Random;
+
+public class Philosopher implements Runnable {
+
+	private int id;
+	private Chopsticks leftChopStick;
+	private Chopsticks rightChopStick;
+	private volatile boolean isFull = false;
+	private Random random;
+	private int eatingCounter;
+	
+	public Philosopher(int id, Chopsticks leftChopStick, Chopsticks rightChopStick){
+		this.id = id;
+		this.leftChopStick = leftChopStick;
+		this.rightChopStick = rightChopStick;
+		this.random = new Random();
+	}
+	
+	@Override
+	public void run() {
+		
+		try{
+			
+			while( !isFull ){
+				
+				think();
+				
+				if( leftChopStick.pickUp(this, State.LEFT) ){
+					if( rightChopStick.pickUp(this, State.RIGHT)){
+						eat();
+						rightChopStick.putDown(this, State.RIGHT);
+					}
+					
+					leftChopStick.putDown(this, State.LEFT);
+				}	
+			}
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+	}
+	
+	private void think() throws InterruptedException {
+		System.out.println(this+" is thinking...");
+		Thread.sleep(this.random.nextInt(1000));
+	}
+	
+	private void eat() throws InterruptedException {
+		System.out.println(this+" is eating...");
+		this.eatingCounter++;
+		Thread.sleep(this.random.nextInt(1000));
+	}
+	
+	public int getEatingCounter(){
+		return this.eatingCounter;
+	}
+	
+	public void setFull(boolean isFull){
+		this.isFull = isFull;
+	}
+	
+	@Override
+	public String toString() {
+		return "Philosopher-"+this.id;
+	}
+}
+

Concurrency_Multithreading_and_Parallel_Computing_in_Java/bin/org/ashfaq/dev/concepts/Concurrent_Collections/SecondThread.class

@@ -0,0 +1,4 @@
+package org.ashfaq.dev.problems.DiningPhilosophers;
+public enum State {
+	LEFT, RIGHT;
+}