前言

在Java并发开发的过程中，我们总会遇到让一个线程等待另一个线程完成的案例。其实要实现这样的方式有很多，今天我主要给大家介绍的是怎么使用wait和notify实现这样一个案例。

简单介绍

• wait() - 方法wait()的作用是使当前执行代码的线程进行等待，它是Object类的方法，该方法用来将当前线程置入预执行队列中，并且在wait所在的代码行处停止执行，直到接到通知或被中断为止。
  在调用wait方法之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait方法。

• notify() - 同wait方法一样，也需要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。

wait和notify调用时，如果没有持有适当的锁，将会抛出IllegalMonitorStateException的异常。它是一个RuntimeException的子类。

来个例子

为了模拟业务，我这里创建了三个类，NotifyThread、WaitThread和TestWaitNotify。其中NotifyThread和WaitThread为继承了Thread的线程，TestWaitNotify为执行这二个线程的调用类。具体如下：

NotifyThread.java

public class NotifyThread extends Thread {
    private final Object lock;

    public NotifyThread(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            // 做一些业务逻辑相关的事。。。。
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 业务逻辑完成了...
            System.out.println("开始 notify time= " + System.currentTimeMillis());
            lock.notify();
            System.out.println("结束 notify time= " + System.currentTimeMillis());
        }
    }
}

WaitThread.java类

public class WaitThread extends Thread {
    private final Object lock;

    public WaitThread(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                long start = System.currentTimeMillis();
                System.out.println("开始 wait time= " + start);
                lock.wait();
                long end = System.currentTimeMillis();
                System.out.println("结束 wait time= " + end);
                System.out.print("wait time = " + (end - start));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

TestWaitNotify.java

public class TestWaitNotify {

    public static void main(String[] args) {
        Object lock = new Object();
        WaitThread t1 = new WaitThread(lock);
        t1.start();
        NotifyThread t2 = new NotifyThread(lock);
        t2.start();
    }
}

运行结果如下：

等待、通知机制的例子

总结

我们从上面的例子中可以看到，Wait和notify都被包裹在同步块synchronized中，而synchronized持有的对象锁都是lock。那如果它们持有的对象锁不一样会有什么样的结果呢？

扩展

我们把TestWaitNotify类改造成如下：

public class TestWaitNotify {

    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();
        WaitThread t1 = new WaitThread(lock1);
        t1.start();
        NotifyThread t2 = new NotifyThread(lock2);
        t2.start();
    }
}

其结果如下;

wait、notify被包在持有不同对象锁的运行结果

NotifyThread线程运行3秒之后就已经结果了，而WaitThread却一直在等待中线程被唤醒或中断掉。

所以wait和notify所在的同步块或同步方法持有的对象锁是相同的情况下，才会有等待的线程被唤醒的可能。