java 中多线程之间的通讯之等待唤醒机制

wait

notify ()

nitifyAll ()

都使用在同步中，因为要对持有监视器（锁）的线程操作

所以要使用在同步中，因为只有同步才具有锁

为什么这些操作线程的方法要定义object类中呢

因为这些方法在操作同步中线程时。都必须要标识他们所操作线程只有的锁

只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒

不可以对不同锁中的线程进行唤醒

也就是说，等待和唤醒必须是同一个锁

而锁可以使任意对象，所以可以被任意对象调用的方法定义object类中 

class Res
{
    String name;
    String  sex;
    boolean flag = false;
}

class Input implements Runnable
{
    private Res r ;
    Input (Res r){
    this.r = r;
    }
    public void run (){
        int x = 0;
        while (true)
        {
            synchronized (r) {
                if (r.flag)
                    try {r.wait();}catch(Exception e){}
                    if (x==0){
                        r.name = "java";
                        r.sex = "man";
                    }
                    else
                    {
                        r.name = "杰克";
                        r.sex = "女女vn";
                        
                    }
                    x = (x+1)%2;
                    r.flag = true;
                    r.notify();
                    
                }
            }
            
        }            
        
    }
    


class Output implements Runnable
{
       private Res r;    
       Output (Res r){
           
           this.r = r;
       }
       public void run (){
           while (true){
               synchronized(r){
                   
                   if (!r.flag)
                       
                       try {r.wait();}catch (Exception e){}
                       System.out.println (r.name+"..."+r.sex);
                       r.flag = false;
                       r.notify();
                       
                   }
               }
               
           }
           
       }

public class InputOutputDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
         System.out.println ("ddddd");
        Res r = new Res ();
        Input input = new Input (r);
        Output output = new Output (r);
        

        Thread t1 = new Thread (input);
        Thread t2 = new Thread (output);
        t1.start();
        t2.start();
    }

}

在1.5之后出现了lock关键字因此使用这个关键字丰富和我们平时开发习惯

 同时Condition 取代了wait notifly nitiflyAll

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;


public class one {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
System.out.println("ddd");
RRRRRRR res = new RRRRRRR();

Producer p1 = new Producer(res);
Producer p2 = new Producer(res);

consumers c1 = new consumers(res);
consumers c2 = new consumers(res);

Thread t1 = new Thread(p1);
Thread t2 = new Thread(p2);
Thread t3 = new Thread(c1);
Thread t4 = new Thread(c2);

t1.start();
t2.start();
t3.start();
t4.start();
    }

}
class RRRRRRR
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    
    private Lock lock = new ReentrantLock();
    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();
    public  void set (String name) throws InterruptedException{
        lock.lock();
        try{
            while (flag)
                condition_pro.await();
                this .name = name + "--" + count++;
                System.out.println(Thread.currentThread().getName()+"生产商品"+this.name);
                flag = true;
                condition_con.signal();
        }
        finally{
        lock.unlock();    
        }
        }
        
    
    
    public  void out()throws InterruptedException {
        lock.lock();
        try{
        while (!flag)
            condition_con.await();
            System.out.println(Thread.currentThread().getName() + "消费了" + this.name);
            flag = false;
            condition_pro.signal();
        }
        finally{
        lock.unlock();    
        }
    }
}
/*
 * 生产者
 */
 class Producer implements Runnable
{
    private RRRRRRR res;
    Producer (RRRRRRR res){
        
        this.res = res;
    }
    public void run(){
        
        try{
            while (true){
                
                res.set ("牙膏");
            }
        }
        catch(InterruptedException e){
            
            
        }
        }
        
    }
 /*
  * 消费者
  */
 class consumers implements Runnable
 {

     private RRRRRRR res;
     consumers(RRRRRRR res){
         
         this.res = res;
     }
     public void run(){
         try{
             
             while (true){
                 res.out();
             }
         }
         catch(InterruptedException e){
             
             
         }
     }
 }