版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/xzx4959/article/details/83245905
使用wait和notify方法实现线程间的通信需要注意以下两点：
- wait和notify必须配合synchronized去使用。
- wait可以释放锁，notify不释放锁。
1.wait和notify的简单应用
使用wait和notify设计如下程序，t1线程向一个List中添加元素，当List的长度为5时向t2线程发出通知；t2等待线程t1的通知，当t2线程接收到t1的通知时，中断线程。程序代码如下：
public class ListAdd {
private volatile static List list = new ArrayList();
public void add() {
list.add("Hello World");
}
public int size() {
return list.size();
}
public static void main(String[] args) {
final ListAdd listAdd = new ListAdd();
// 实例化出来一个 lock
// 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
final Object lock = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
synchronized (lock) {
for (int i = 0; i < 10; i++) {
listAdd.add();
System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
Thread.sleep(500);
if (listAdd.size() == 5) {
System.out.println("已经发出通知..");
lock.notify();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
if (listAdd.size() != 5) {
try {
System.out.println("t2进入...");
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");
throw new RuntimeException();
}
}
}, "t2");
t2.start();
t1.start();
}
}
程序的运行结果如下：
t2进入...
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
10
当前线程：t2收到通知线程停止..
Exception in thread "t2" java.lang.RuntimeException
at com.bjsxt.base.conn008.ListAdd$2.run(ListAdd.java:66)
at java.lang.Thread.run(Thread.java:748)
首先声明一个lock锁对象，然后启动t2线程，获得lock锁，此时list中的元素等于5，t2线程等待并释放锁。 t1线程获得lock锁，循环执行元素添加操作，当list的长度为5的时候，发送notify通知，但t1线程仍然持有lock锁，继续执行，直到线程执行结束释放锁。t2线程重新获得lock锁，并被唤醒，继续执行程序到结束。
2.CountDownLatch
上面的程序存在什么样的问题呢？
在上面的程序中，当list元素达到5个的时候，并没有实时的去释放锁，而必须等到程序执行结束，如果我们想实时的释放锁可以使用CountDownLatch。
public class ListAdd2 {
private volatile static List list = new ArrayList();
public void add() {
list.add("Hello World");
}
public int size() {
return list.size();
}
public static void main(String[] args) {
final ListAdd2 list2 = new ListAdd2();
// 1 实例化出来一个 lock
// 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
// 构造函数中的数字表示countDown调用的次数
final CountDownLatch countDownLatch = new CountDownLatch(1);
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
list2.add();
System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
if (list2.size() == 5) {
System.out.println("已经发出通知..");
countDownLatch.countDown();
}
Thread.sleep(500);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
if (list2.size() != 5) {
try {
System.out.println("t2进入...");
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");
throw new RuntimeException();
}
}, "t2");
t2.start();
t1.start();
}
}
执行结果如下：
t2进入...
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
当前线程：t2收到通知线程停止..
Exception in thread "t2" java.lang.RuntimeException
at com.bjsxt.base.conn008.ListAdd2$2.run(ListAdd2.java:67)
at java.lang.Thread.run(Thread.java:748)
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
从执行结果我们可以看出，list中的元素达到5个的时候，等待的线程t2会立即得到执行，此时t1线程会继续执行，并不会受到阻塞。final CountDownLatch countDownLatch = new CountDownLatch(1)中的构造函数数字，表示t2线程继续执行时countDown需要调用的次数。
3.wait和notify实现队列
使用wait和notify实现一个BlockingQueue（阻塞队列），支持阻塞的放入和得到数据。需要实现两个简单的方法put和take操作。
put(anObject)：把anObject加到Blocking里。如果BlockingQueue中没有空间，则调用此方法的线程被阻塞，直到BlockingQueue里面有空间再继续。
take：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻塞进入等待状态直到BlockingQueue有新的数据被加入。
public class MyQueue {
//1 需要一个承装元素的集合
private LinkedList<Object> list = new LinkedList<Object>();
//2 需要一个计数器
private AtomicInteger count = new AtomicInteger(0);
//3 需要制定上限和下限
private final int minSize = 0;
private final int maxSize;
//4 构造方法
public MyQueue(int size) {
this.maxSize = size;
}
//5 初始化一个对象 用于加锁
private final Object lock = new Object();
//put(anObject): 把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断，直到BlockingQueue里面有空间再继续.
public void put(Object obj) {
synchronized (lock) {
while (count.get() == this.maxSize) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//1 加入元素
list.add(obj);
//2 计数器累加
count.incrementAndGet();
//3 通知另外一个线程（唤醒）
lock.notify();
System.out.println("新加入的元素为:" + obj);
}
}
//take: 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入.
public Object take() {
Object ret = null;
synchronized (lock) {
while (count.get() == this.minSize) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//1 做移除元素操作
ret = list.removeFirst();
//2 计数器递减
count.decrementAndGet();
//3 唤醒另外一个线程
lock.notify();
}
return ret;
}
public int getSize() {
return this.count.get();
}
public static void main(String[] args) {
final MyQueue mq = new MyQueue(5);
mq.put("a");
mq.put("b");
mq.put("c");
mq.put("d");
mq.put("e");
System.out.println("当前容器的长度:" + mq.getSize());
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
mq.put("f");
mq.put("g");
}
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
Object o1 = mq.take();
System.out.println("移除的元素为:" + o1);
Object o2 = mq.take();
System.out.println("移除的元素为:" + o2);
}
}, "t2");
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
程序的执行结果如下：
新加入的元素为:a
新加入的元素为:b
新加入的元素为:c
新加入的元素为:d
新加入的元素为:e
当前容器的长度:5
移除的元素为:a
新加入的元素为:f
移除的元素为:b
新加入的元素为:g