java使用wait(),notify(),notifyAll()实现等待/通知机制

public class WaitNotify {
    static boolean flag=true;
    static Object lock=new Object();

    static class Wait implements Runnable{
        @Override
        public void run() {
            synchronized (lock){
                while(flag){
                    try{
                        System.out.println(Thread.currentThread()+" flag is true. wait " +
                                "@ "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        lock.wait();
                    }catch (InterruptedException e){
                    }
                }
            }
            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() {
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock. notify " +
                        "@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag = false;
                SleepUtils.second(5);
            }
            synchronized (lock){
                System.out.println(String.format(Thread.currentThread() + " hold lock again. sleep " +
                        "@" + new SimpleDateFormat("HH:mm:ss").format(new Date())));
                SleepUtils.second(5);
            }
        }
    }

    public static void main(String[] args) {
        Thread waitThread=new Thread(new Wait(),"WaitThread");
        waitThread.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){

        }
        Thread notifyThread=new Thread(new Notify(),"NotifyThread");
        notifyThread.start();
    }
}

程序执行结果：

Thread[WaitThread,5,main] flag is true. wait @ 14:41:12
Thread[NotifyThread,5,main] hold lock. notify @ 14:41:13
Thread[NotifyThread,5,main] hold lock again. sleep @14:41:18
Thread[WaitThread,5,main] flag is false.running @14:41:23

1.使用wait(),notify(),notifyAll()方法之前，要获取同一个对象的锁。

2.调用wait()方法之后，线程会从RUNABLE状态变为WAITING状态，并会释放对象锁，并会将线程移入到对象的等待队列中。

3.notify()和notifyAll()调用之后，等待的线程的wait方法并不会立马返回，需要锁空闲的时候，等待的线程获取了锁，wait()方法才会返回。

4.调用了notify()和notifyAll()方法之后，notify会将一个线程从等待队列放置到同步队列，同步队列是因为锁被占有而处于BLOCKED阶段的线程，notifyAll则是将等待队列中所有的线程都移动到同步队列，这两个方法都是将线程从WAITING状态变为BLOCKED状态。

5.从wait方法返回的条件是获得了调用对象的锁。

该程序的执行流程是首先WaitThread获取了lock,然后waitThread调用wait方法，会释放锁，并将锁移入等待队列，接着notifyThread会获取锁，调用notifyAll，但是wait()方法并没有返回，因为lock没有释放，notifyThread会睡眠5秒，这时同步队列中有两个线程要获取lock,一个是notifyThread,一个是WaitThread,结果显示是notifyThread又重新获取了锁，所以这时的wait方法依然不能返回，当notifyThread执行完了之后，释放锁，waitThread获取了锁，并且wait方法返回，waitThread执行完成。

java等待/通知经典模式

等待方：

1）获取对象锁

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

3）条件满足则执行相应逻辑

对应的伪代码：

synchronized(对象){
   while(条件不满足){
      对象.wait()   
   }      
   执行对应逻辑代码
}

通知方：

1）获取对象锁

2）改变条件

3）通知所有在该对象上等待的线程

对应的伪代码：

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

　

java中的Thread.join()方法使用了等待/通知经典范式

java中的Thread.join()也算是线程通信的一种方式，表示挂起当前线程，执行子线程，等到子线程执行完成之后再返回。join()方法还提供了两个超时方法，如果子线程在规定时间没有终止，就会从join()方法中返回。

Thread.join()方法源代码：

   //join函数的超时方法   
　　public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
　　　　
　　　　　//如果设置的超时时间小于0，抛出异常
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

　　　　　//调用wait()的时候采用delay
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
   }

    public final synchronized void join(long millis, int nanos)
    throws InterruptedException {

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        join(millis);
    }

   public final void join() throws InterruptedException {
        join(0);
    }    

子线程执行完成之后会调用子线程的notifyAll(),会通知所有等待在该线程对象上的方法。