多线程编程艺术（3）-多线程等待通知编程模型

本文内容来源于《多线程编程艺术》一书，本人阅读过程的总结

关键知识点：

1、调用wait()方法后，会释放对象的锁

等待方遵循如下原则。

1）获取对象的锁。

2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。

3）条件满足则执行对应的逻辑。对应的伪代码如下。

  synchronized(对象) {       
         while(条件不满足) {              
               对象.wait();      
           }      
         对应的处理逻辑
  }

通知方遵循如下原则。

1）获得对象的锁。

2）改变条件。

3）通知所有等待在对象上的线程。对应的伪代码如下。

    synchronized(对象) {
        改变条件       
        对象.notifyAll();
     }

代码实例如下：

public class WaitNotify {

    static boolean flag = true;
    static Object lock = new Object();

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(1);
        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }
    static class Wait implements Runnable {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            synchronized (lock) {
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "flag is true,"
                                + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 条件满足时，完成工作
                System.out.println(Thread.currentThread() + " flag is false. running   @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

    static class Notify implements Runnable {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock. notify @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep  @ "
                        + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

等待通知模型的进化：等待超时模式

在正式的系统环境中，必须设置超时时间，避免未知原因造成无限期等待。

上述描述等待超时模式的伪代码如下。

// 对当前对象加锁
public synchronized Object get(long mills) throws InterruptedException {       
       long future = System.currentTimeMillis() + mills;      
       long remaining = mills;       // 当超时大于0并且result返回值不满足要求       
      while ((result == null) && remaining > 0) {             
           wait(remaining);              
           remaining = future - System.currentTimeMillis();       
     }              
     return result;
}