wait(),notify() 与 await(), signal(), signalAll() 的区别

参考文章

Oracle 官方文档 Condition Interface
How is await() different from wait() ?

wait() 和 notify() 的使用方式

• wait() 与 notify() 需要搭配 synchronized 关键字使用， 示例如下

// 线程 A 的代码
synchronized(obj_A)
{
    while(!condition){ 
        obj_A.wait();
    }
    // do something 
}
1
2
3
4
5
6
7
8

// 线程 B 的代码
synchronized(obj_A)
{
    if(!condition){ 
        // do something ...
        condition = true;
        obj_A.notify();
    }
}
1
2
3
4
5
6
7
8
9

• 为什么 wait(), notify() 需要搭配 synchronized 关键字使用
  
  • wait(), notify() 操作的目的是基于某种条件， 协调多个线程间的运行状态， 由于涉及到多个线程间基于共享变量的相互通信， 必然需要引入某种同步机制， 以确保wait(), notify() 操作在线程层面的原子性
  • 更多详细解析可参考文章为什么wait()和notify()需要搭配synchonized关键字使用

await() 和 signal() 的使用方式

• wait() 和 notify() 方法是 Object 的方法， 而 await() 和 signal() 方法是接口 Condition 的方法， 官方文档对于 await() 和 signal() 有如下的说明。

Condition factors out the Object monitor methods (wait, notify and notifyAll) into distinct objects to give the effect of having multiple wait-sets per object, by combining them with the use of arbitrary Lock implementations.

• 翻译一下就是， Condition 这个接口把 Object 的 wait(), notify(), notifyAll() 分解到了不同的对象中， 搭配上任意一种 Lock 的使用， 使得一个对象可以拥有多个等待集

• 这里有一个术语是 waitset， 具体含义是

  • 每个对象都有一个等待集， 该等待集是一个线程的集合。
    
  • wait(), notify(), notifyAll() 方法的调用会对等待集中的线程进行移入或移除操作

• 所以， await() 和 signall 的添加， 实际上是为我们提供了一种方便的基于同一个锁， 实现多个条件的 wait() 和 notify() 操作， 以一个有界缓冲区的生产消费操作为例（该例子实际上是 ArrayBlockingQueue 的简化版 ， 感兴趣的读者可以直接阅读源码）

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

• 上面的例子中， 在一个 lock 控制的临界区中， 出现了两种条件（notFull, notEmpty）的操作。
• 下面假设我们要通过 wait() 和 notify() 粗暴地进行替换

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     synchronized(lock)
     {
        while (count == items.length)
            lock.wait();
        items[putptr] = x;
        if (++putptr == items.length) putptr = 0;
        ++count;
        lock.notify();
     }
   }

   public Object take() throws InterruptedException {
     synchronized(lock){
       while (count == 0)
         lock.wait();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       lock.notify();
       return x;
     } 
   }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• 显然， 上述的代码仅仅在消费者和生产者分别只有一个时可以工作， 在有多个生产者和消费者时， 生产者A 可能会唤醒生产者 B 造成错误的结果， 为了避免这一错误。 则需要多个添加更多的对象， 使用嵌套的 synchronized 代码块。

class BoundedBuffer {
        final Lock lock = new ReentrantLock();
        final Condition notFull = lock.newCondition();
        final Condition notEmpty = lock.newCondition();

        final Object[] items = new Object[100];
        int putptr, takeptr, count;

        public void put(Object x) throws InterruptedException {
            synchronized (lock) {
                synchronized (notFull) {
                    while (count == items.length)
                        notFull.wait();
                }

                items[putptr] = x;
                if (++putptr == items.length) putptr = 0;
                ++count;
                synchronized (notEmpty) {
                    notEmpty.notify();
                }
            }
        }

        public Object take() throws InterruptedException {
            synchronized (lock) {
                synchronized (notEmpty)
                {
                    while (count == 0)
                        notEmpty.wait();
                }

                Object x = items[takeptr];
                if (++takeptr == items.length) takeptr = 0;
                --count;
                synchronized (notFull)
                {
                    notFull.notify();
                }
                return x;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

• 显然， 代码的易用性和可读性都不如 Condition 方法的 await() 和 signal() 。

总结

await(), signal()，signalAll() 的功用和 wait(), notify(), notifyAll() 基本相同， 区别是， 基于 Condition 的 await(), signal(), signalAll() 使得我们可以在同一个锁的代码块内， 优雅地实现基于多个条件的线程间挂起与唤醒操作。