多线程--哲学家就餐问题

1、当哲学家的左右筷子均是可用的时候才能就餐，否则等待，很容易理解，一次最多能有两个人同时就餐

public class PhilosopherEating
{
private static Thread[] threads = new Thread[5];
public static void main(String[] args)
{
System.out.println("Hello World!");
for(int i = 0 ; i < 5; i ++){
threads[i] = new Thread(new Philosopher(i));
threads[i].start();
}
//当前线程组活动线程数
while(Thread.activeCount()>1){
Chopstick.monitor();
try{
Thread.sleep(1000);
}catch(InterruptedException ex){

}
}
}
}
/*
*   哲学家进程
*/
class Philosopher implements Runnable
{
//所有哲学家共用五支筷子
private static Chopstick chopstick = new Chopstick();

//哲学家编号
private int id = 0;

public Philosopher(int id){
this.id = id;
}

public void run(){
while(true){
if(new Random().nextBoolean()){
//取筷子
chopstick.take(id);
eat();
//放筷子
chopstick.down(id);

}else{
think();
}
}
}
//就餐
private void eat(){
int time = new Random().nextInt(10);
try{
System.out.println(id + "就餐"+time+"s");
Thread.sleep(time*1000);
System.out.println(id + "就餐完成！");
}catch(InterruptedException ex){
System.out.println("ex:eat");
}
}
//思考
private void think(){
int time = new Random().nextInt(10);
try{
System.out.println(id + "思考"+time+"s");
Thread.sleep(time*1000);
}catch(InterruptedException ex){
System.out.println("ex:think");
}
}

}
/*
*   筷子
*   作为资源
*/
class Chopstick
{
private static Lock lock = new ReentrantLock();
private static Condition chopstick = lock.newCondition();

//五支筷子是否在使用
private static boolean[] used = new boolean[5];

//取筷子
public void take(int id){
//获取锁
lock.lock();
try{
//左筷子,右筷子可以使用
while(used[id] || used[(id+1)%5]){
chopstick.await();
}
used[id] = true;
used[(id+1)%5] = true;
}catch(InterruptedException ex){

}finally{
//释放锁
lock.unlock();
}
}
//放筷子
public void down(int id){
lock.lock();
used[id] = false;
used[(id+1)%5] = false;
chopstick.signalAll();
lock.unlock();
}
//监控是否发生死锁，如果所有的筷子都是使用状态，则说明死锁
public static boolean monitor(){
boolean flag = true;
for(int i = 0 ; i < 5 ; i ++ ){
if(used[i] == false){
flag = false;
break;
}
}
return flag;
}
}

2、创建一个服务员，每次哲学家就餐都需要询问服务员

public class PhilosopherEating2
{
private static Thread[] threads = new Thread[5];
public static void main(String[] args)
{
System.out.println("Hello World!");
for(int i = 0 ; i < 5; i ++){
threads[i] = new Thread(new Philosopher(i));
threads[i].start();
}
//当前线程组活动线程数
while(Thread.activeCount()>1){
if(Waiter.monitor()){
System.out.println("死锁!!!!!!!!!!!!!!!!");
}
try{
Thread.sleep(100);
}catch(InterruptedException ex){

}
}
}
}
/*
*   哲学家进程
*/
class Philosopher implements Runnable
{
//服务员
private static Waiter waiter = new Waiter();

//哲学家编号
private int id = 0;

public Philosopher(int id){
this.id = id;
}

public void run(){
while(true){
if(new Random().nextBoolean()){
if(waiter.ask(id)){
eat();
waiter.put(id);
}
}else{
think();
}
}
}
//就餐
private void eat(){
int time = new Random().nextInt(10);
try{
System.out.println(id + "就餐"+time+"s");
Thread.sleep(time*100);
System.out.println(id + "就餐完成！");
}catch(InterruptedException ex){
System.out.println("ex:eat");
}
}
//思考
private void think(){
int time = new Random().nextInt(10);
try{
System.out.println(id + "思考"+time+"s");
Thread.sleep(time*100);
}catch(InterruptedException ex){
System.out.println("ex:think");
}
}

}

/*
*   服务员
*/
class Waiter
{
//五支筷子是否在使用
private static boolean[] used = new boolean[5];

//询问是否可以就餐
public synchronized boolean ask(int id){
if(used[id] || used[(id+1)%5]){
return false;
}
used[id] = true;
used[(id+1)%5] = true;
return true;
}
//交筷子
public synchronized void put(int id){

used[id] = false;
used[(id+1)%5] = false;

}
//监控是否发生死锁，如果所有的筷子都是使用状态，则说明死锁
public static boolean monitor(){
boolean flag = true;
for(int i = 0 ; i < 5 ; i ++ ){
if(used[i] == false){
flag = false;
break;
}
}
return flag;
}
}

3、使用信号量，每个哲学家只能先申请大号筷子，然后再申请小号筷子，即使是4号哲学家，也只能是先申请4号筷子，然后再申请0号筷子

public class PhilosopherEating3
{
private static Thread[] threads = new Thread[5];
public static void main(String[] args)
{
System.out.println("Hello World!");
for(int i = 0 ; i < 5; i ++){
threads[i] = new Thread(new Philosopher(i));
threads[i].start();
}
//当前线程组活动线程数
while(Thread.activeCount()>1){
int count = 0;
for(int i = 0 ; i < 5; i ++){
if(threads[i].getState().equals(Thread.State.BLOCKED)){
count++;
}
}
if(count == 5){
System.out.println("死锁！！！！！！！！");
for(int i = 0 ; i < 5; i ++ ){
System.out.println(threads[i].getState());
}
}
try{
Thread.sleep(1000);
}catch(InterruptedException ex){

}
}
}
}
/*
*   哲学家进程
*/
class Philosopher implements Runnable
{
//所有哲学家共用五支筷子
private static Chopstick chopstick = new Chopstick();

//哲学家编号
private int id = 0;

public Philosopher(int id){
this.id = id;
}

public void run(){
while(true){
if(new Random().nextBoolean()){
//取筷子
chopstick.take(id);
eat();
//放筷子
chopstick.down(id);

}else{
think();
}
}
}
//就餐
private void eat(){
int time = new Random().nextInt(10);
try{
System.out.println(id + "就餐"+time+"s");
Thread.sleep(time*100);
System.out.println(id + "就餐完成！");
}catch(InterruptedException ex){
System.out.println("ex:eat");
}
}
//思考
private void think(){
int time = new Random().nextInt(10);
try{
System.out.println(id + "思考"+time+"s");
Thread.sleep(time*100);
}catch(InterruptedException ex){
System.out.println("ex:think");
}
}

}
/*
*   筷子
*   作为资源
*/
class Chopstick
{

//五支筷子资源
private static Semaphore[] used = new Semaphore[5];

public Chopstick(){
for(int i = 0; i < 5; i ++){
used[i] = new Semaphore(1);
}
}
//取筷子
public void take(int id){
//获取锁
try{
if(id < 4){
//先申请号大的筷子
used[id+1].acquire();
//申请号小的筷子
used[id].acquire();
}else{
//id = 4时比较特殊
//先申请号大的筷子
used[id].acquire();
//申请号小的筷子
used[0].acquire();
}
}catch(InterruptedException ex){

}finally{

}
}
//放筷子
public void down(int id){
//先释放小号，再释放大号
if(id < 4){
used[id].release();
used[id+1].release();
}else{
//id = 4时比较特殊
used[0].release();
used[id].release();
}
}
}