java多线程的等待和通知机制，两种实现方法

一.等待和通知机制

        等待和通知机制其实就是同步机制，帮助线程之间通信，让一个线程通知另外一个线程某种特定的条件发生了。java 多线程中的等待唤醒，有两种实现方法

       ①通过wait和notify，notifyAll方法来配合完成的

        ②通过线程锁(ReentrantLock)、线程通信状态(Condition)

二.synchronized、wait和notify

synchronized

用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，它获得了对象锁， 其它线程对该对象所有同步代码部分的访问都被暂时阻塞。    

 可以放在方法名上，也可以是语句块如代码：

class  Base {

     // java中的锁可以使任意对象，这个对象没什么要求，仅仅表示它是一个锁

     private  Object sync_obj =  new  Object();

             

     // 放在方法名的锁默认是this

     synchronized  public  void  add() {

         System.out.println( "1" );

     }

                 

     public  void  add2() {

         // 和上面那个方法是同一个锁

         synchronized  ( this ) {

             System.out.println( "2" );

         }

     }

             

     public  void  get() {

         synchronized  (sync_obj) {

             System.out.println( "2" );

         }

     }

}

void wait()

等待某种条件的发生。这是Object类的方法，而且必须在被同步的方法或者代码块中被调用。

void wait(long timeout)

等待一个条件的发生。但是，如果在设定的时间内没有收到通知，就返回。这是Object类的方法，而且必须在被同步的方法或者代码块中被调用。

void notify()

通知线程其等待的条件已经发生了。这是Object类的方法，而且必须在被同步的方法或者代码块中被调用。

        wait() / notify() 都是Object类的方法。每一个Java对象都是直接或间接继承Object类，所以任何Java对象都支持这种机制。所以等待和通知机制存在于Java系统中每一个对象里。

        等待和通知机制并不指定该条件到底是什么。事实上，一般情况下也不需要指定。程序员决定一个线程在执行到代码的某处时在某个对象上调用wait()方法进行等待，另一个线程执行一段代码后认为条件满足了，则在同一个对象上调用notify()方法，通知等待该对象的线程。

        当我们使用wait(),notify(),notifyAll()方法时，很容易出现java.lang.IllegalMonitorStateException异常。这个异常的原因就是当前线程没有获得对象的锁，或者说，当前调用的对象不是锁对象。

        所以我们必须明白调用wait(),notify(),notifyAll()的对象必须是当前锁对象。常见的毛病就是使用了线程对象来调用这些方法，如代码：

class Cunsumer extends Thread {

    private Resource res;

    public Cunsumer(Resource res) {

        super();

        this.res = res;

    }

    public void run() {

        while (true) {

            synchronized (res) {//注意这里的锁是res，不是this

                if (!res.flag)

                    try {   

                        //这个地方，调用wait()的对象是this或者说是当前线程

                        //但是前面的锁又不是this，因此会出异常

                        wait();

                    } catch (InterruptedException e) {

                    }

                res.get();

                res.flag = false;

                //这个地方，调用wait()的是res，而且前面的synchronized 的锁就是res，因此这里不会出异常

                res.notify();

            }

        }

    }

}

因此，记住一点：wait和notify，notifyAll 必须是让当前的锁来调用。

下面代码是一个发送数据、接收数据并解析的模型，一般接收数据和解析数据比较耗时，所以放在线程中处理。

两点注意：1.接收数据是一个线程一直在运行，直到收到解析完成的通知才结束。

               2.解析数据一般比较耗时，可能存在无法解析完成，所以存在超时时间5秒

public class SendReceive {
    static boolean finish=false;
    static boolean parse=false;
    private static int count=0;
    private Object sync_obj = new Object();
    
    
    public static void SendData(){
        System.out.println("send data");
    }
    
    public synchronized void initReceive(final boolean isInit){
        new Thread(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(!finish){
                    if(isInit){
                        System.out.println("receive data:>>>"+(count++));
                    }else{
                        System.out.println("wait for init receive");
                        continue;
                    }
                    
                    try {
                        Thread.sleep(50); //此处必须加sleep，让出CPU时间，以便主线程更改parse状态，否则线程不断执行,parse值未修改
                        
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                    if(parse){
                        System.out.println("parse data:>>>");
                        synchronized(sync_obj){
                            sync_obj.notify();  //唤醒调用的是当前的锁对象
                            parse=false;
                        }
                    }else{
                        System.out.println("no data to parse>>>");
                    }
                }
            }
            
        }.start();
    }
    
    public void doSendReceive(){
        parse=true;
        SendData();
        
        synchronized(sync_obj){
            try {
                sync_obj.wait(5000);
                //等待调用的是当前的锁对象
     } catch (InterruptedException e) {

e.printStackTrace(); 

  } 

      }

 } 

    public static void main(String[] args) {

    SendReceive sr=new SendReceive(); 

 sr.initReceive(true); for(int i=0;i<10;i++){ 

sr.doSendReceive();

         }

 finish=true; 

 }
如上程序可以完成子线程和主线程的等待通知需求，当子线程解析数据完成，通知主线程等待结束，继续向下走。

三.线程锁(ReentrantLock)、线程通信状态(Condition)

        多线程并发索取某一资源，要求该资源线程安全（即线程同步），每一线程在使用资源时候会需要检查资源状态，如果状态不符合立即通知资源的维护服务进行维护，维护完毕后发布通知表示该资源可以继续被索取使用
 
        所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作。

        Lock和synchronized机制的主要区别:
            synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取了多个锁时, 它们必须以相反的顺序释放. synchronized机制对锁的释放是隐式的, 只要线程运行的代码超出了synchronized语句块范围, 锁就会被释放. 
            Lock机制必须显式的调用Lock对象的unlock()方法才能释放锁, 这为获取锁和释放锁不出现在同一个块结构中, 以及以更自由的顺序释放锁提供了可能.

public static Lock indexLock = new ReentrantLock();   //线程锁

public static Condition indexCondition = indexLock.newCondition();  //线程条件变量,每一个Lock可以有任意数据的Condition对象，Condition是与Lock绑定的

public int waitDecode() {
int index = 0;
indexLock.lock();   //锁
try {
if (commonIndex <= 0) {// 判断数据是否符合条件，没有则继续等待 
  indexCondition.await(5000，TimeUnit.MILLISECONDS); //等待signal释放，或者超时
}
//indexCondition.signal();  //signal就是唤醒Condition队列中的第一个非CANCELLED节点线程，而signalAll就是唤醒所有非CANCELLED节点线程在需要唤醒的时候调用该函数，释放Condition.await
} catch (Exception e) {
}  
finally {
indexLock.unlock();//释放锁
}
return index;
}