java中的wait(),notify(),notifyAll(),synchronized方法

wait(),notify(),notifyAll()三个方法不是Thread的方法，而是Object的方法。意味着所有对象都有这三个方法，因为每个对象都有锁，所以自然也都有操作锁的方法了。这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。

java文档的解释

wait导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行.

　　notify唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。此方法只应由作为此对象监视器的所有者的线程来调用.

　　"当前的线程必须拥有此对象监视器"与"此方法只应由作为此对象监视器的所有者的线程来调用"说明wait方法与notify方法必须在同步块内执行,即synchronized(obj之内).

　　调用对像wait方法后,当前线程释放对像锁,进入等待状态.直到其他线程(也只能是其他线程)通过notify 方法，或 notifyAll.该线程重新获得对像锁.

例子代码：

说明：线程运行3秒后调用wait等待，6秒后主线程调用notify唤醒等待线程。

 /**
  * Created on 2016/1/31.
  */
 public class MyThread implements Runnable {
     private Object flag;
     private String threadName;

     public MyThread(Object flag,String threadName) {
         this.flag = flag;
         this.threadName = threadName;
     }

     @Override
     public void run(){
         try{
             for(int i = 0; i < 10;i++){
                 if(i == 3){
                     synchronized (this.flag){
                         System.out.println("3秒后线程调用wait睡眠");
                         this.flag.wait();
                     }
                 }
                 System.out.println(this.threadName + " " + i);
                 Thread.sleep(1000);
             }
         } catch(InterruptedException e){
             e.printStackTrace();
         }

     }
 }

main方法：

 import java.io.IOException;

 /**
  * Created  on 2016/1/31.
  */
 public class TestMain {
     public static void main(String[] args) {
         Object object = new Object();
         MyThread myThread1 = new MyThread(object,"thread1");
 //        MyThread myThread2 = new MyThread(object,"thread2");
         Thread test1 = new Thread(myThread1);
         test1.start();

 //        Thread test2 = new Thread(myThread1);
 //        test2.start();

         try{
             Thread.sleep(6000);
             System.out.println("6秒后唤醒线程");
             synchronized (object){
                 object.notify();
             }
             System.in.read();
         } catch(InterruptedException e){
             e.printStackTrace();
         } catch(IOException e){
             e.printStackTrace();
         }

     }
 }

结果：

测试notifyAll（MyThread代码不变）

main方法代码：

 import java.io.IOException;

 /**
  * Created on 2016/1/31.
  */
 public class TestMain {
     public static void main(String[] args) {
         Object object = new Object();
         MyThread myThread1 = new MyThread(object,"thread1");
         MyThread myThread2 = new MyThread(object,"thread2");
         Thread test1 = new Thread(myThread1);
         test1.start();

         Thread test2 = new Thread(myThread2);
         test2.start();

         try{
             Thread.sleep(6000);
             System.out.println("6秒后唤醒线程");
             synchronized (object){
                 object.notifyAll();
             }
             System.in.read();
         } catch(InterruptedException e){
             e.printStackTrace();
         } catch(IOException e){
             e.printStackTrace();
         }

     }
 }

结果截图：