1. 引言
这篇博客通过实现一个有界容器来表述Java里wait,notify,notifyAll的用法。这些关键词用的概率不高,但是阅读一些源码的时候还是经常会遇到,写一下增强记忆。
具体生产实践的时候,对于我来说我是不推荐程序员们直接使用这些的,JAVA1.5之后提供很多直接可用的线程安全的容器,能少写代码就少些代码,降低了测试的需求,
也减少出错的可能性。
2. 一个线程安全的容量有限的栈
先把代码贴上:
package com.sabo.concurrent;
/**
* Created by canbin.zhang on 2016/3/29.
*/
public class SaboStack {
private final int[] _data;
public SaboStack(int limit) {
_data = new int[limit];
}
private final Object lock = new Object();
private int size = 0;
public void push(int v) {
synchronized (lock) {
while (size >= _data.length) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
_data[size] = v;
++size;
lock.notifyAll();
}
}
public int pop() {
int v;
synchronized (lock) {
while (size == 0) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
v = _data[size - 1];
--size;
lock.notifyAll();
return v;
}
}
}
要是stack的容量无限的话, 其实这里的实现只要synchronized关键词就能实现了,但是大部分情况下内存的使用总是受到限制,比如栈最多只能用10个int大小的空间,这样的话实现就需要多考虑一个逻辑“当栈里没元素怎么办? 当栈的空间满了该怎么处理?”。
Java里给出了这样一个机制,当遇到了这种情况时调用wait方法导致该调用线程被放在等待队列里, 当情况发生改变的时候(条件可能满足)被唤醒。
wait的使用方法基本采用一个固定的模式:
synchronized (lock) {
while (/*条件*/) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//满足条件之后的其他处理代码
1). lock.wait()方法调用之后当前线程将放弃所占有的锁,这样其他线程就有机会改变目前的状态。
2). 注意判断条件满不满足使用while而不是if,这是因为当前线程被唤醒之后条件又不满足了。
3). notify 和 notifyAll的区别:notify唤醒等待队列里的一个线程, notifyAll唤醒等待队列里的所有线程,这能想到什么问题呢? notify唤醒的线程无法改变条件怎么办, 这样的话可能会导致死锁。
另外能想到的问题是: notify和notifyAll并没有说明哪些线程应该被唤醒,这样导致不该醒的线程又进入了等待队列,这将导致比较低的效率。
比如这里, 我希望当stack的元素数量size >= 1的时候去唤醒那些因为stack空而被放在等待队列的线程。
class SaboStack2 {
private final int[] _data;
private int size = 0;
public SaboStack2(int limit) {
_data = new int[limit];
}
private final ReentrantLock lock = new ReentrantLock();
private final Condition lock_empty = lock.newCondition();
private final Condition lock_full = lock.newCondition();
public void push(int v) {
lock.lock();
while (size >= _data.length) {
try {
lock_full.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
_data[size] = v;
++size;
lock_empty.signalAll();
lock.unlock();
}
public int pop() {
int v;
lock.lock();
while (size == 0) {
try {
lock_empty.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
v = _data[size - 1];
--size;
lock_full.signalAll();
lock.unlock();
return v;
}
}
这里采用Condition lock将那些等待的线程分为两组,有了区分度,能一定程度上提升效率。
如果你是Linux程序员熟悉pthread_cond_wait可能会更喜欢第二种的实现方式, 但是应该还是看不习惯, 弄出个等待队列这样的玩意儿怎么看都有些蛋疼。