面试官：你是如何调用 wait() 方法的？使用 if 还是 while？别答错了！

点击关注公众号，Java干货及时送达

问题1 为什么是while 而不是if

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)atTestWhileWaitBuf.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’的时候报错了.最新面试题整理好了，大家可以在Java面试库小程序在线刷题。

那么我们来分析下:

假设现在有A, B两个线程来执行get 操作, 我们假设如下的步骤发生了:

A 拿到了锁 line 0
A 发现size==0, (line 1), 然后进入等待,并释放锁 (line 2)
此时B拿到了锁, line0, 发现size==0, (line 1), 然后进入等待,并释放锁 (line 2)
这个时候有个线程C往里面加了个数据1, 那么 notifyAll 所有的等待的线程都被唤醒了.
AB 重新获取锁, 假设又是A拿到了. 然后他就走到line 3, 移除了一个数据, (line4) 没有问题.
A 移除数据后想通知别人, 此时list的大小有了变化, 于是调用了notifyAll (line5), 这个时候就把B给唤醒了, 那么B接着往下走.
这时候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了。点击关注公众号，Java干货及时送达

问题2:什么时候用notifyAll或者notify

大多数人都会这么告诉你:

当你想要通知所有人的时候就用notifyAll, 当你只想通知一个人的时候就用notify.

但是我们都知道notify实际上我们是没法决定到底通知谁的(都是从等待集合里面选一个). 那这个还有什么存在的意义呢?

在上面的例子中,我们用到了notifyAll, 那么下面我们来看下用notify是否可以工作呢？另外，多线程系列面试题和答案全部整理好了，微信搜索Java技术栈，在后台发送：面试，可以在线阅读。

那么代码变成下面的样子:

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语义实现了有且只有一个线程可以执行同步块里面的代码.

P2 想来放,发现满了,在wait里面等了

P3 想来放,发现满了,在wait里面等了

C1想来拿, C2, C3 就在get里面等着

C1开始执行, 获取1, 然后调用notify 然后退出

如果C1把C2唤醒了, 所以P2 (其他的都得等.)只能在put方法上等着. (等待获取synchoronized (this) 这个monitor)

C2 检查while循环发现此时队列是空的, 所以就在wait里面等着