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){

          }
      }
  }