public class WaitDemo implements Runnable {

     private Object lock;

     public WaitDemo(Object lock) {

         this.lock = lock;

     }

     @Override

     public void run() {

         synchronized (lock) {

             System.out.println("Begin wait() ThreadName=" + Thread.currentThread().getName());

             try {

                 // [STEP-1] WaitDemo线程立刻释放获得的对象锁lock，并放弃CPU，进入等待队列。

                 lock.wait();

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             // [STEP-4] WaitDemo有机会获得另一个线程释放的锁，并从等待的地方起开始执行。

             System.out.println("End wait() ThreadName=" + Thread.currentThread().getName());

         }

     }

 }

 public class NotifyDemo implements Runnable {

     private Object lock;

     public NotifyDemo(Object lock) {

         this.lock = lock;

     }

     @Override

     public void run() {

         synchronized (lock) {

             System.out.println("Begin notify() ThreadName=" + Thread.currentThread().getName());

             // [STEP-2] NotifyDemo线程唤醒其他挂起的线程(WaitDemo线程)。但是此时它并不立即释放锁。

             lock.notify();

             try {

                 System.out.println("Sleep 3s...");

                 Thread.sleep(3000);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println("End notify() ThreadName=" + Thread.currentThread().getName());

             // [STEP-3] 释放锁。

         }

     }

 }

 // 该实例无法保证假设在线程WaitDemo和NotifyDemo的先后执行顺序。如果线程B先执行了notify()然后结束了，线程A才去执行wait()，那此时，线程A将无法被正常唤醒了

 public class DemoTest {

     public static void main(String[] args) throws InterruptedException {

         Object o = new Object();

         // WaitDemo

         Thread a = new Thread(new WaitDemo(o));

         a.setName("WaitDemo");

         a.start();

         Thread.sleep(2000);

         // NotifyDemo

         Thread b = new Thread(new NotifyDemo(o));

         b.setName("NotifyDemo");

         b.start();

     }

 }