Obect的wait、notify 和 notifyAll是Object提供的同步方法，也就是所有对象都生而带来的方法，估计搞java的没有不知道这几个方法的。那么他究竟是怎么使用的呢？在此处记录一下自己的理解。
先上一个最最最简单的例子。
1 public class SynchronizedTest { 2 public static void main(String[] args) throws Exception { 3 Thread mt = new Thread(){ 4 @Override 5 public void run() { 6 synchronized (this) { 7 System.out.println("开始阻塞啦"); 8 try { 9 this.wait(); 10 } catch (InterruptedException e) { 11 e.printStackTrace(); 12 } 13 System.out.println("阻塞结束啦"); 14 } 15 } 16 }; 17 mt.start(); 18 Thread.sleep(500); 19 synchronized (mt) { 20 mt.notify(); 21 } 22 } 23 }运行结果：
开始阻塞啦 阻塞结束啦上面的例子中，wait和notify方法都是在synchronized代码体中执行的，如果没有经过synchronized修饰，直接使用则会抛出java.lang.IllegalMonitorStateException异常。
至于原因，jdk源码wait方法中的描述为：
* The current thread must own this object's monitor. The thread * releases ownership of this monitor and waits until another thread * notifies threads waiting on this object's monitor to wake up * either through a call to the {@code notify} method or the * {@code notifyAll} method. The thread then waits until it can * re-obtain ownership of the monitor and resumes execution.翻译过来：
当前线程必须拥有此对象监视器。该线程释放对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。总结过来就是：要想使用wait等一系列方法，必须拥有当前对象的监视器（很多地方称为监视器锁）。
那么什么是对象的监视器呢？
简单说监视器是java对象为实现同步操作的一种机制，使用javap查看上边例子的线程部分的反编译指令：
1 final class com.xxx.SynchronizedTest$1 extends java.lang.Thread { 2 com.xxx.SynchronizedTest$1(); 3 Code: 4 0: aload_0 5 1: invokespecial #1 // Method java/lang/Thread."<init>":()V 6 4: return 7 8 public void run(); 9 Code: 10 0: aload_0 11 1: dup 12 2: astore_1 13 3: monitorenter 14 4: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 15 7: ldc #3 // String 开始阻塞啦 16 9: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 17 12: aload_0 18 13: invokevirtual #5 // Method java/lang/Object.wait:()V 19 16: goto 24 20 19: astore_2 21 20: aload_2 22 21: invokevirtual #7 // Method java/lang/InterruptedException.printStackTrace:()V 23 24: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 24 27: ldc #8 // String 阻塞结束啦 25 29: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 26 32: aload_1 27 33: monitorexit 28 34: goto 42 29 37: astore_3 30 38: aload_1 31 39: monitorexit 32 40: aload_3 33 41: athrow 34 42: return 35 Exception table: 36 from to target type 37 12 16 19 Class java/lang/InterruptedException 38 4 34 37 any 39 37 40 37 any 40 }13行和27行可以看到monitorenter和monitorexit两条指令，monitorenter是尝试获取monitor，如果成功则执行，不成功则阻塞等待。monitorexit是释放monitor。
那么如何拥有该对象的监视器呢？
jdk源码notify方法中列举了三种方法：
By executing a synchronized instance method of that object. By executing the body of a {@code synchronized} statement that synchronizes on the object. For objects of type {@code Class,} by executing a synchronized static method of that class.翻译大概是：
通过执行此对象的同步实例方法。 通过执行在此对象上进行同步的 synchronized 语句的代码块。 对于 Class 类型的对象，可以通过执行该类的同步静态方法。我理解的就是被synchronized 修饰的方法或代码块（如果是代码块，需要使用同一对象做为synchronized的参数，目的是为了获取相同的监视器）。结合上边反编译的线程匿名内部类指令可以看到，使用synchronized 修饰的代码会使用monitorenter指令获取监视器，wait和notify必须获得监视器才能正确执行。
下面列举一下针对文章开始实例的错误示范：
错误实例1
1 public class SynchronizedTest { 2 public static void main(String[] args) throws Exception { 3 Thread mt = new Thread(){ 4 @Override 5 public void run() { 6 synchronized (this) { 7 System.out.println("开始阻塞啦"); 8 try { 9 this.wait(); 10 } catch (InterruptedException e) { 11 e.printStackTrace(); 12 } 13 System.out.println("阻塞结束啦"); 14 } 15 } 16 }; 17 mt.start(); 18 Thread.sleep(500); 19 // synchronized (mt) { 20 mt.notify(); 21 // } 22 } 23 }执行结果：
开始阻塞啦 Exception in thread "main" java.lang.IllegalMonitorStateException at java.lang.Object.notify(Native Method) at xxx原因：
notify方法没有获得监视器。
错误实例2：
1 public class SynchronizedTest { 2 public static void main(String[] args) throws Exception { 3 Thread mt = new Thread(new Runnable() { 4 @Override 5 public void run() { 6 synchronized (this) { 7 System.out.println("开始阻塞啦"); 8 try { 9 this.wait(); 10 } catch (InterruptedException e) { 11 e.printStackTrace(); 12 } 13 System.out.println("阻塞结束啦"); 14 } 15 } 16 }); 17 mt.start(); 18 Thread.sleep(500); 19 synchronized (mt) { 20 mt.notify(); 21 } 22 } 23 }
执行结果：
开始阻塞啦 （线程持续wait中。。。原因：
这个例子是我最开始的写法，放在这里有点不太合适，因为他并不是wait和notify错误使用导致的问题，而是错误使用Runnable导致的，最终我还是决定放上来吧，防止有人也会一时想不明白。
例子中使用 new Runnable 创建了一个匿名内部类并作为构造参数传给new Thread，导致构造的对象mt和匿名内部类的this不是同一个对象。所以导致notify不起作用= =、
