目录
本篇文章默认大家对synchronized跟ReentrantLock有一定了解。
下面一段简单的代码，主要是通过3个线程对count进行累计来进行模拟多线程的场景。
/**
* zhongxianyao
*/
public class Test {
private static final int N = 3;
private int count = 0;
public void doSomething() {
// 实际业务中，这里可能是远程获取数据之类的耗时操作
for (int i=0; i<1000_000; i++) {
synchronized (this) {
count ++;
}
}
}
public static void main(String[] args) throws Exception {
Test test = new Test();
for (int i=0; i<N; i++) {
Runnable runnable = () -> test.doSomething();
new Thread(runnable).start();
}
Thread.sleep(1000);
System.out.println(test.count);
}
}
在多线程编程中，一旦调用start()后，什么时候真正分配cpu时间片运行是不确定的，运行多久也是不确定的，所以有时候可能根据经验，预估一下程序的运行时间，然后进行sleep，最后获取结果。但这种方式太low了，有没有那么一种方式，当程序获取到结果后进行通知呢？下面将引出今天要讲的等待/通知机制。
/**
* zhongxianyao
*/
public class Test {
private static final int N = 3;
private int count = 0;
private int finishCount = 0;
public void doSomething() {
for (int i=0; i<1000_000; i++) {
synchronized (this) {
count ++;
}
}
synchronized (this) {
finishCount ++;
notify();
}
}
public static void main(String[] args) {
Test test = new Test();
for (int i=0; i<N; i++) {
Runnable runnable = () -> test.doSomething();
new Thread(runnable).start();
}
synchronized (test) {
try {
while (test.finishCount != N) {
test.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println(test.count);
}
}
结果输出3000000，结果是正确，是自己想要的。
接口描述如下
As in the one argument version,interrupts and spurIoUs wakeups are possible,and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
翻译一下：在一个论点版本中，中断跟虚假唤醒是可能，所以这个方法应始终放在一个循环中。
加上一句自己的解释：一般在项目中，一个线程不可能无缘无故等待，总是需要在某种条件下进行等待，而且其他线程唤醒这个线程的时候，可能用的是notifyAll()，数据被其他线程消费了，这里需要在判断一下是否满足特定的条件再继续运行。
解释1：wait()本身设计的逻辑就是在释放锁进行等待，如果没有获取锁，谈何释放。
解释2：通常在wait()的方法前面都会有while语句的判断，在这两条语句中会有时间间隔，可能会破坏程序，需要加上synchronized同步代码块来保证原子操作。
因为wait()等方法都是锁级别操作，再者Java提供的锁都是对象级别的而不是线程级别的，每个对象都有锁。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。
在上面的例子中，如果notify();那行代码删除，wait()改为wait(100)，如下，那么程序是否可以获取到正确的结果呢？
/**
* zhongxianyao
*/
public class Test {
private static final int N = 3;
private int count = 0;
private int finishCount = 0;
public void doSomething() {
for (int i=0; i<1000_000; i++) {
synchronized (this) {
count ++;
}
}
synchronized (this) {
finishCount ++;
//notify();
}
}
public static void main(String[] args) {
Test test = new Test();
for (int i=0; i<N; i++) {
Runnable runnable = () -> test.doSomething();
new Thread(runnable).start();
}
synchronized (test) {
try {
while (test.finishCount != N) {
test.wait(100);
}
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println(test.count);
}
}
运行结果是3000000，是正确的结果，看了一下文档，发现这个字段跟直觉理解的不一样，直觉告诉我，这个是最长等多久，等太久了就InterruptedException，结果不是。这个方法设置的时间，是说等待多久就唤醒自己。
下面的代码，把前一个例子中的synchronized代码块，换成了lock()/unlock，notify()换成了condition.signal()，wait()换成了condition.await()。运行结果也是正确的。
/**
* zhongxianyao
*/
public class Test {
private static final int N = 3;
private int count = 0;
private int finishCount = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void doSomething() {
for (int i=0; i<1000_000; i++) {
synchronized (this) {
count ++;
}
}
lock.lock();
finishCount ++;
if (finishCount == N) {
condition.signal();
}
lock.unlock();
}
public static void main(String[] args) {
Test test = new Test();
for (int i=0; i<N; i++) {
Runnable runnable = () -> test.doSomething();
new Thread(runnable).start();
}
test.lock.lock();
try {
test.condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
test.lock.unlock();
}
System.out.println(test.count);
}
}
public class ConditionTest {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
try {
long time = System.currentTimeMillis();
lock.lock();
System.out.println("await start");
condition.await();
System.out.println("await end " + (System.currentTimeMillis() - time) + "ms");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
},"Thread-await").start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
try {
lock.lock();
System.out.println("signal start");
TimeUnit.SECONDS.sleep(5);
condition.signal();
System.out.println("signal end");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println("signal unlock");
}
},"Thread-signal").start();
}
}
多次运行，结果都是一样的，如下：
await start
signal start
signal end
signal unlock
await end 5005ms
从运行结果可以看出，await()后，锁就释放了，但signal()后，锁不释放，一定要在unlock()之后，锁才释放，await()才会往下执行。
既然唤醒了其他线程，又不释放锁，可以调整唤醒的时机。一般在实际代码中，也是不建议signal()方法后添加逻辑，应该直接释放锁。
同理，上面的notify()也是在synchronized代码块结束后，wait()后面的语句才能真正执行。
把上面的condition.await()改为condition.await(1,TimeUnit.SECONDS),然后获取返回值，运行结果返回的是false。
这个时候，如果把TimeUnit.SECONDS.sleep(5)，condition.signal()这两行代码顺序调换一下，那么await的返回值就是true。
再看到官方文档对这个返回值的描述，如下
{@code false} if the waiting time detectably elapsed
before return from the method,else {@code true}
翻译过来，大致意思就是“如果等待时间可以在方法返回之前检测到返回false，否则返回true”。但实际测试结果却是await()被唤醒的时候，而不是方法返回的时候。
