面试官：你是如何调用 wait（）方法的？使用 if 块还是循环？为什么？

csdn_life18

已于 2024-06-05 10:29:52 修改

阅读量58

点赞数

分类专栏：面试知识文章标签： java面试

于 2024-06-04 08:49:50 首次发布

原文链接：https://www.importnew.com/26584.html)

版权

面试知识专栏收录该内容

37 篇文章 4 订阅

订阅专栏

文章目录

结论：wait() 方法应该在循环调用。

也就是使用轮询遍历的方式来避免报错，保证能够正常访问到数据。

问：为什么是 while 而不是 if ？

大多数人都知道常见的使用 synchronized 代码:

synchronized (obj) {
     while (check pass) {
      wait();
    }
    // do your business
}

那么问题是为啥这里是 while 而不是 if 呢？这个问题我最开始也想了很久，按理来说已经在 synchronized 块里面了嘛，就不需要了。这个也是我前面一直是这么认为的，直到最近看了一个 Stackoverflow 上的问题才对这个问题有了比较深入的理解。

试想我们要试想一个有界的队列。那么常见的代码可以是这样：

import cn.hutool.core.collection.CollUtil;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


@Slf4j
public class IfWaitExceps {
    private final int MAX = 5;
    private final List<Integer> list = new ArrayList<>();

    /**
     * synchronized修饰的同步方法， 向集合固定的数据
     *
     * @param v
     * @throws InterruptedException
     */
    synchronized void put(int v) throws InterruptedException {
        if (list.size() == MAX) {
            wait();
        }
        list.add(v);
        notifyAll();
    }

    /**
     * synchronized修饰的同步方法， 从集合中娶数据
     *
     * @return
     * @throws InterruptedException
     */
    synchronized int get() throws InterruptedException {
        // line 0
        if (CollUtil.isEmpty(list)) {  // line 1
            log.info("线程 " + Thread.currentThread().getName() + " : 进入时，列表为空，进入等待状态");
            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：

下面代码中使用的 log jar包在另外一篇文章：【lombok问题】使用了@Slf4j，但是log没有info的方法。

 public static void main(String[] args) throws InterruptedException {
        final IfWaitExceps buf = new IfWaitExceps();
        ExecutorService es = Executors.newFixedThreadPool(11);
        for (int i = 0; i < 1; i++)
            es.execute(() -> {
                while (true) {
                    try {
                        int val = (int) (Math.random() * 10.0);
                        buf.put(val);
                        log.info("线程 " + Thread.currentThread().getName() + " : 执行结束，成功添加值到ArrayList：" + val);
                        Thread.sleep(20);
                    } catch (IndexOutOfBoundsException | InterruptedException e) {
                        log.warn("添加失败，或者睡眠运行报错，程序报错", e);
                        break;
                    }
                }
            });

        for (int i = 0; i < 10; i++) {
            es.execute(() -> {
                while (true) {
                    try {
                        int result = buf.get();
                        log.info("线程 " + Thread.currentThread().getName() + " :  获取到的结果: " + result);
                        Thread.sleep(10);
                    } catch (IndexOutOfBoundsException | InterruptedException e) {
                        log.warn("获取失败，或者睡眠运行报错，程序报错", e);
                        break;
                    }
                }
            });
        }

        es.shutdown();
        es.awaitTermination(1, TimeUnit.DAYS);
    }

这段代码很快或者说一开始就会报错：

09:19:52.052 [pool-1-thread-2] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-2 : 进入时，列表为空，进入等待状态
09:19:52.063 [pool-1-thread-11] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-11 : 进入时，列表为空，进入等待状态
09:19:52.063 [pool-1-thread-9] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-9 : 进入时，列表为空，进入等待状态
09:19:52.063 [pool-1-thread-1] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-1 : 执行结束，成功添加值到ArrayList：1
09:19:52.063 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 :  获取到的结果: 1
09:19:52.063 [pool-1-thread-7] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-7 : 进入时，列表为空，进入等待状态
09:19:52.064 [pool-1-thread-6] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-6 : 进入时，列表为空，进入等待状态
09:19:52.066 [pool-1-thread-2] WARN javads.concurrents.IfWaitExceps - 获取失败，或者睡眠运行报错，程序报错
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
	at java.util.ArrayList.rangeCheck(ArrayList.java:657)
	at java.util.ArrayList.remove(ArrayList.java:496)
	at javads.concurrents.IfWaitExceps.get(IfWaitExceps.java:46)
	at javads.concurrents.IfWaitExceps.lambda$main$1(IfWaitExceps.java:77)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
09:19:52.066 [pool-1-thread-10] WARN javads.concurrents.IfWaitExceps - 获取失败，或者睡眠运行报错，程序报错
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
	at java.util.ArrayList.rangeCheck(ArrayList.java:657)
	at java.util.ArrayList.remove(ArrayList.java:496)
	at javads.concurrents.IfWaitExceps.get(IfWaitExceps.java:46)
	at javads.concurrents.IfWaitExceps.lambda$main$1(IfWaitExceps.java:77)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
09:19:52.066 [pool-1-thread-9] WARN javads.concurrents.IfWaitExceps - 获取失败，或者睡眠运行报错，程序报错
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
	at java.util.ArrayList.rangeCheck(ArrayList.java:657)
	at java.util.ArrayList.remove(ArrayList.java:496)
	at javads.concurrents.IfWaitExceps.get(IfWaitExceps.java:46)
	at javads.concurrents.IfWaitExceps.lambda$main$1(IfWaitExceps.java:77)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
09:19:52.094 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 : 进入时，列表为空，进入等待状态
09:19:52.103 [pool-1-thread-1] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-1 : 执行结束，成功添加值到ArrayList：9
09:19:52.103 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 :  获取到的结果: 9
09:19:52.114 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 : 进入时，列表为空，进入等待状态
09:19:52.124 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 :  获取到的结果: 4
09:19:52.124 [pool-1-thread-1] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-1 : 执行结束，成功添加值到ArrayList：4
09:19:52.135 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 : 进入时，列表为空，进入等待状态
09:19:52.144 [pool-1-thread-1] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-1 : 执行结束，成功添加值到ArrayList：6
09:19:52.144 [pool-1-thread-8] INFO javads.concurrents.IfWaitExceps - 线程 pool-1-thread-8 :  获取到的结果: 6

很明显，在 remove 的时候报错了。那么我们来分析下：

假设现在有 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 的线程数，就能看到更好的效果
for (int i = 0; i < 1; i++)
//for (int i = 0; i < 3; i++)
es.execute(new Runnable() {
     @Override
    public void run() {
        while (true ) {
            try {
                buf.put(1);
                Thread.sleep(20);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
        }
    }
});

同样的，我们可以尝试修改 put 的线程数和 get 的线程数来发现如果 put 里面不是 while 的话也是不行的。

我们可以用一个外部周期性任务来打印当前 list 的大小，你会发现大小并不是固定的最大5：

下面的代码用了 10 个线程来 put，1 个线程来 get：

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。

P1 放了一个数字1。
P2 想来放，发现满了，在wait里面等了。
P3 想来放，发现满了，在 wait 里面等了。
C1 想来拿，C2，C3 就在 get 里面等着。
C1 开始执行，获取1，然后调用 notify 然后退出。
- 如果 C1 把 C2 唤醒了，所以P2 (其他的都得等)只能在put方法上等着。(等待获取synchoronized (this) 这个monitor)。
- C2 检查 while 循环发现此时队列是空的，所以就在 wait 里面等着。
- C3 也比 P2 先执行，那么发现也是空的，只能等着了。
这时候我们发现 P2、C2、C3 都在等着锁，最终 P2 拿到了锁，放一个 1，notify，然后退出。
P2 这个时候唤醒了P3，P3发现队列是满的，没办法，只能等它变为空。
这时候没有别的调用了，那么现在这三个线程(P3, C2,C3)就全部变成 suspend 了，也就是死锁

转载：
面试官：你是如何调用 wait（）方法的？使用 if 块还是循环？为什么？
https://blog.csdn.net/qfguan/article/details/121226964

csdn_life18

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面试官：你是如何调用 wait（）方法的？使用 if 块还是循环？为什么？

wait();那么问题是为啥这里是 while 而不是 if 呢？这个问题我最开始也想了很久，按理来说已经在 synchronized 块里面了嘛，就不需要了。这个也是我前面一直是这么认为的，直到最近看了一个 Stackoverflow 上的问题才对这个问题有了比较深入的理解。试想我们要试想一个有界的队列。wait();
复制链接

扫一扫

专栏目录