[JAVA]等待通知机制的2种实现

最近笔者在空闲之余，温习了下JAVA多线程编程。经常看，却经常忘记。可能是由于用的不多的缘故吧。这里针对多线程的等待通知的机制的2种实现进行总结。加深理解和认识。

等待通知机制

首先介绍下什么是等待通知机制。这里举一个生活的例子。

大家去餐馆吃饭的时候，会取号进行”等待“。等到号了，餐馆工作人员会”通知“你前去就餐。

这就是一个简单的等待通知的例子。好了，接下来介绍下它的2种实现。

wait()和notify()实现等待通知机制

源码见Github

去餐馆就餐的客人（等待者）

package com.zju.javastudy.waitnotify.demo1;

/**
* @author Arthur
* @Date 2017/12/28
* @Decription: 饿着的人，去餐馆取号，等待者
*/
public class HungryPeople implements Runnable {
/**
* 座位
*/
private Object seat;

public HungryPeople(Object seat) {
this.seat = seat;
}

@Override
public void run() {
synchronized (seat) {
try {
System.out.println("HungryPeople：去餐馆吃饭，先取号...");
seat.wait();//等待叫号
System.out.println("HungryPeople：到号，有位置了！可以吃饭了！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}

餐馆（通知者）

package com.zju.javastudy.waitnotify.demo1;

/**
* @author Arthur
* @Date 2017/12/28
* @Decription: 餐馆，通知者
*/
public class Restaurant implements Runnable {
/**
* 座位，实质就是锁
*/
private Object seat;

public Restaurant(Object o) {
this.seat = o;
}

@Override
public void run() {
try {
//模拟等待
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (seat) {
System.out.println("Restaurant:有空位，通知客人来就餐...");
seat.notify();//通知到号
System.out.println("Restaurant:完成通知");

}

}

}

测试

package com.zju.javastudy.waitnotidy.demo1;

import com.zju.javastudy.waitnotify.demo1.HungryPeople;
import com.zju.javastudy.waitnotify.demo1.Restaurant;
import org.junit.Test;

import static sun.jvm.hotspot.runtime.PerfMemory.start;

/**
* @author Arthur
* @Date 2017/12/28
* @Decription: 餐馆取号吃饭的测试例子
*/
public class WaitNotidyTest1 {

@Test
public void test() throws InterruptedException {
Object seat = new Object();//座位
Restaurant restaurant = new Restaurant(seat);
HungryPeople hungryPeople = new HungryPeople(seat);
Thread hungryPeopleThread = new Thread(hungryPeople);

hungryPeopleThread.start();
Thread restaurantThread = new Thread(restaurant);
restaurantThread.start();

//子线程结束后，再结束main线程
hungryPeopleThread.join();
restaurantThread.join();
}
}

结果

使用Condition实现部分通知

源码见Github

去餐馆就餐的客人（等待者）

package com.zju.javastudy.waitnotify.demo2;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
* @author Arthur
* @Date 2017/12/28
* @Decription: 饿着的人，去餐馆取号，等待者
*/
public class HungryPeople implements Runnable {
/**
* 所有座位
*/
private ReentrantLock allSeat;

/**
* 等待的桌（大桌/小桌）
*/
private Condition seat;

public HungryPeople(ReentrantLock allSeat,Condition seat) {
this.allSeat = allSeat;
this.seat = seat;
}

@Override
public void run() {
allSeat.lock();
try {
seat.await();
System.out.println(Thread.currentThread().getName()+":等到位置");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
allSeat.unlock();
}

}
}

餐馆（通知者）

package com.zju.javastudy.waitnotify.demo2;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
* @author Arthur
* @Date 2017/12/28
* @Decription: 餐馆，通知者
*/
public class Restaurant implements Runnable {

/**
* 所有座位
*/
private ReentrantLock allSeat;

/**
* 小桌
*/
private Condition smallSeat;

/**
* 大桌
*/
private Condition bigSeat;

public Restaurant(ReentrantLock allSeat,Condition smallSeat, Condition bigSeat) {
this.allSeat = allSeat;
this.smallSeat = smallSeat;
this.bigSeat = bigSeat;
}

@Override
public void run() {
//这里模拟通知大桌
try {
allSeat.lock();
Thread.sleep(2000);
System.out.println("Restaurant:有大桌空位，通知客人来就餐...");
bigSeat.signalAll();
System.out.println("Restaurant:完成大桌通知");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
allSeat.unlock();
}

//这里模拟通知小桌
try {
Thread.sleep(3000);
allSeat.lock();
System.out.println("Restaurant:有小桌空位，通知客人来就餐...");
smallSeat.signalAll();
System.out.println("Restaurant:完成小桌通知");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
allSeat.unlock();
}
}
}

测试

package com.zju.javastudy.waitnotidy.demo2;

import com.zju.javastudy.waitnotify.demo2.HungryPeople;
import com.zju.javastudy.waitnotify.demo2.Restaurant;
import org.junit.Test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
* @author Arthur
* @Date 2017/12/28
* @Decription: 餐馆取号吃饭的测试例子
*/
public class WaitNotidyTest2 {

@Test
public void test() throws InterruptedException {
ReentrantLock allSeat = new ReentrantLock();//座位
Condition smallSeat = allSeat.newCondition();//小桌
Condition bigSeat = allSeat.newCondition();//大桌

//实例化 餐馆，小桌客人和大桌客人
Restaurant restaurant = new Restaurant(allSeat,smallSeat,bigSeat);
HungryPeople hungryPeopleWaitSmall = new HungryPeople(allSeat,smallSeat);
HungryPeople hungryPeopleWaitBig = new HungryPeople(allSeat,bigSeat);

//小桌客人线程
Thread hungryPeopleWaitSmallThread = new Thread(hungryPeopleWaitSmall);
hungryPeopleWaitSmallThread.setName("smallSeatPeople");

//大桌客人线程
Thread hungryPeopleWaitBigThread = new Thread(hungryPeopleWaitBig);
hungryPeopleWaitBigThread.setName("bigSeatPeople");

//餐馆线程
Thread restaurantThread = new Thread(restaurant);

//开始模拟
hungryPeopleWaitSmallThread.start();
hungryPeopleWaitBigThread.start();
restaurantThread.start();

//子线程结束再结束main线程
hungryPeopleWaitSmallThread.join();
hungryPeopleWaitBigThread.join();
restaurantThread.join();
}
}

结果

这里通过2种实现，对等待通知进制进行了一个小结。例子可能不太恰当。欢迎批评指正。