不要让这个世界的复杂性妨碍你的后退。要成为一个口头主义者，将解决人类的不平等视为己任。它将成为你生命中最重要的经验之一。
问：为什么是 while 而不是 if ？
大多数人都晓得常见的应用 synchronized 代码:
synchronized (obj) { while (check pass) { wait(); } // do your business}那么问题是为啥这里是 while 而不是 if 呢？这个问题我最开始也想了很久，按理来说曾经在 synchronized 块外面了嘛，就不须要了。这个也是我后面始终是这么认为的，直到最近看了一个 Stackoverflow 上的问题才对这个问题有了比拟深刻的了解。
试想咱们要试想一个有界的队列。那么常见的代码能够是这样：
static class Buf { private final int MAX = 5; private final ArrayList<Integer> list = new ArrayList<>(); synchronized void put(int v) throws InterruptedException { if (list.size() == MAX) { wait(); } list.add(v); notifyAll(); } synchronized int get() throws InterruptedException { // line 0 if (list.size() == 0) { // line 1 wait(); // line2 // line 3 } int v = list.remove(0); // line 4 notifyAll(); // line 5 return v; } synchronized int size() { return list.size(); }}留神到这里用的 if，那么咱们来看看它会报什么错呢？
上面的代码用了 1 个线程来 put，10 个线程来 get：
final Buf buf = new Buf();ExecutorService es = Executors.newFixedThreadPool(11);for (int i = 0; i < 1; i++) es.execute(new Runnable() { @Override public void run() { while (true) { try { buf.put(1); Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); break; } } } });for (int i = 0; i < 10; i++) { es.execute(new Runnable() { @Override public void run() { while (true) { try { buf.get(); Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); break; } } } });}es.shutdown();es.awaitTermination(1, TimeUnit.DAYS);这段代码很快或者说一开始就会报错：
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 at java.util.ArrayList.rangeCheck(ArrayList.java:653) at java.util.ArrayList.remove(ArrayList.java:492) at TestWhileWaitBuf.get(TestWhileWait.java:80)atTestWhileWait2.run(TestWhileWait.java:47) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) at java.lang.Thread.run(Thread.java:745)很显著，在 remove 的时候报错了。那么咱们来剖析下：
假如当初有 A，B 两个线程来执行 get 操作，咱们假如如下的步骤产生了：
1. A 拿到了锁 line 0。
2. A 发现 size==0, (line 1)，而后进入期待，并开释锁 (line 2)。
3. 此时 B 拿到了锁，line0，发现 size==0，(line 1)，而后进入期待，并开释锁 (line 2)。
4. 这个时候有个线程 C 往里面加了个数据 1，那么 notifyAll 所有的期待的线程都被唤醒了。
5. AB 从新获取锁，假如又是 A 拿到了。而后他就走到 line 3，移除了一个数据，(line4) 没有问题。
6. A 移除数据后想告诉他人，此时 list 的大小有了变动，于是调用了 notifyAll (line5)，这个时候就把 B 给唤醒了，那么 B 接着往下走。
7. 这时候 B 就出问题了，因为其实此时的竞态条件曾经不满足了 (size==0)。B 认为还能够删除就尝试去删除，后果就跑了异样了。
那么 fix 很简略，在 get 的时候加上 while 就好了：
synchronized int get() throws InterruptedException { while (list.size() == 0) { wait(); } int v = list.remove(0); notifyAll(); return v;}同样的，咱们能够尝试批改 put 的线程数和 get 的线程数来发现如果 put 外面不是 while 的话也是不行的。
咱们能够用一个内部周期性工作来打印以后 list 的大小，你会发现大小并不是固定的最大5：
final Buf buf = new Buf();ExecutorService es = Executors.newFixedThreadPool(11);ScheduledExecutorService printer = Executors.newScheduledThreadPool(1);printer.scheduleAtFixedRate(new Runnable() { @Override public void run() { System.out.println(buf.size()); }}, 0, 1, TimeUnit.SECONDS);for (int i = 0; i < 10; i++) es.execute(new Runnable() { @Override public void run() { while (true) { try { buf.put(1); Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); break; } } } });for (int i = 0; i < 1; i++) { es.execute(new Runnable() { @Override public void run() { while (true) { try { buf.get(); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); break; } } } });}es.shutdown();es.awaitTermination(1, TimeUnit.DAYS);
这里我想应该说分明了为啥必须是 while 还是 if 了。
问：什么时候用 notifyAll 或者 notify？
大多数人都会这么通知你，当你想要告诉所有人的时候就用 notifyAll，当你只想告诉一个人的时候就用 notify。然而咱们都晓得 notify 实际上咱们是没法决定到底告诉谁的(都是从期待汇合外面选一个)。那这个还有什么存在的意义呢？
在下面的例子中，咱们用到了 notifyAll，那么上面咱们来看下用 notify 是否能够工作呢？
synchronized void put(int v) throws InterruptedException { if (list.size() == MAX) { wait(); } list.add(v); notify();}synchronized int get() throws InterruptedException { while (list.size() == 0) { wait(); } int v = list.remove(0); notify(); return v;}上面的几点是 jvm 通知咱们的：
- 任何时候，被唤醒的来执行的线程是不可预知。比方有 5 个线程都在一个对象上，实际上我不晓得 下一个哪个线程会被执行。
- synchronized 语义实现了有且只有一个线程能够执行同步块外面的代码。
那么咱们假如上面的场景就会导致死锁：
P – 生产者 调用 put。
C – 消费者 调用 get。
1. P1 放了一个数字1。
2. P2 想来放，发现满了，在wait外面等了。
3. P3 想来放，发现满了，在 wait 外面等了。
4. C1 想来拿，C2，C3 就在 get 外面等着。
5. C1 开始执行，获取1，而后调用 notify 而后退出。
- 如果 C1 把 C2 唤醒了，所以P2 (其余的都得等)只能在put办法上等着。(期待获取synchoronized (this) 这个monitor)。
- C2 查看 while 循环发现此时队列是空的，所以就在 wait 外面等着。
- C3 也比 P2 先执行，那么发现也是空的，只能等着了。
6. 这时候咱们发现 P2、C2、C3 都在等着锁，最终 P2 拿到了锁，放一个 1，notify，而后退出。
7. P2 这个时候唤醒了P3，P3发现队列是满的，没方法，只能等它变为空。
8. 这时候没有别的调用了，那么当初这三个线程(P3, C2,C3)就全副变成 suspend 了，也就是死锁了。