为什么-wait-方法需要写在-while-里而不是-if

39次阅读

共计 3960 个字符,预计需要花费 10 分钟才能阅读完成。

不要让这个世界的复杂性妨碍你的后退。要成为一个口头主义者,将解决人类的不平等视为己任。它将成为你生命中最重要的经验之一。

问:为什么是 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 通知咱们的:

  1. 任何时候,被唤醒的来执行的线程是不可预知。比方有 5 个线程都在一个对象上,实际上我不晓得 下一个哪个线程会被执行。
  2. 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 了,也就是死锁了。

正文完
 0