线程间的通信_多生产者多消费者问题_JDK1.5新特性_Lock

对于同步代码块，对于锁的操作是隐式的
但是在JDK1.5之前的这种方法效率有点低，判断会很多，后面升级之后有新的解决方案

jdk1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作

Lock接口：替代了同步代码块或者同步函数，将同步的隐式锁操作变成显示锁操作，同时更为灵活，可以一个锁上加上多组监视器

　　　　　lock():获取锁       unlock():释放锁，通常定义在finally代码块中

Condition接口：替代了Object中的wait notify notifyAll方法，将这些监视器方法单独封装，变成了Condition监视器对象，可以喝任意锁组合

　　　　　　　　await();　　　　singal();       singalAll();

同步代码块到lock的变化：

 import java.util.concurrent.locks.*;//lock在此包中
 class LockDemo{
     public static void main(String[] args) {
         Resrouce r = new Resrouce();
         Producer pro = new Producer(r);
         Consumer con = new Consumer(r);

         Thread t1 = new Thread(pro);
         Thread t2 = new Thread(pro);
         Thread t3 = new Thread(con);
         Thread t4 = new Thread(con);

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

     }
 }

 class Resrouce{
     private String name;
     private int count = 1;
     private boolean flag = false;

     Lock lock = new ReentrantLock();//创建一个锁对象

     public void set(String name){
         lock.lock();
         try{
             while(flag)
                 try{this.wait();}catch(Exception e){}
             this.name = name+count;
             count++;
             System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
             flag = true;
             notifyAll();
         }finally{
             lock.unlock();
         }

     }

     public void out(){
         lock.lock();
         try{
             while(!flag)
                 try{this.wait();}catch(Exception e){}
             System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
             flag = true;
             notifyAll();
         }finally{
             lock.unlock();
         }
     }
 }

 class Producer implements Runnable{
     private Resource r;
     Producer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.set("烤鸭");
         }
     }
 }

 class Consumer implements Runnable{
     private Resource r;
     Consumer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.out();
         }
     }
 }

上述实例中锁换成了lock之后就不能用this来操作wait等方法了，应该用lock锁中的Condition接口中的方法，该接口将Object监视器方法（wait，notify，notifyAll）分解成不同的对象

 import java.util.concurrent.locks.*;
 class LockDemo{
     public static void main(String[] args) {
         Resrouce r = new Resrouce();
         Producer pro = new Producer(r);
         Consumer con = new Consumer(r);

         Thread t1 = new Thread(pro);
         Thread t2 = new Thread(pro);
         Thread t3 = new Thread(con);
         Thread t4 = new Thread(con);

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

     }
 }

 class Resrouce{
     private String name;
     private int count = 1;
     private boolean flag = false;

     Lock lock = new ReentrantLock();

     //通过已有的锁获取该锁上的监视器对象,一个锁可以有多个监视器
     Condition con = lock.newCondition();

     public void set(String name){
         lock.lock();
         try{
             while(flag)
                 try{con.await();}catch(Exception e){}
             this.name = name+count;
             count++;
             System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
             flag = true;
             con.signalAll();

         }finally{
             lock.unlock();
         }
     }

     public void out(){
         lock.lock();
         try{
             while(!flag)
                 try{con.await();}catch(Exception e){}
             System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);

             flag = true;
             con.signalAll();
         }finally{
             lock.unlock();
         }
     }
 }

 class Producer implements Runnable{
     private Resource r;
     Producer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.set("烤鸭");
         }
     }
 }

 class Consumer implements Runnable{
     private Resource r;
     Consumer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.out();
         }
     }
 }

上述实例只有一组监视器，既监视着生产者，又监视着消费者，可以搞两个监视器，一组监视生产者，一组监视消费者

 import java.util.concurrent.locks.*;
 class LockDemo{
     public static void main(String[] args) {
         Resrouce r = new Resrouce();
         Producer pro = new Producer(r);
         Consumer con = new Consumer(r);

         Thread t1 = new Thread(pro);
         Thread t2 = new Thread(pro);
         Thread t3 = new Thread(con);
         Thread t4 = new Thread(con);

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

     }
 }

 class Resrouce{
     private String name;
     private int count = 1;
     private boolean flag = false;

     Lock lock = new ReentrantLock();

     /*
         通过已有的锁获取该锁上的监视器对象,一个锁可以有多个监视器
         Condition con = lock.newCondition();
     */

     //通过已有的锁获取监视器对象（两组），一组监视生产者，一组监视消费者
     Condition Producer_con = lock.newCondition();
     Condition Consumer_con = lock.newCondition();
     public void set(String name){
         lock.lock();
         try{
             while(flag)
                 try{Producer_con.await();}catch(Exception e){}
             this.name = name+count;
             count++;
             System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
             flag = true;
             //con.signalAll();//会发生死锁，所以要用到notifyAll
             Consumer_con.signa();//有了两组监视器后就不用signaAll方法唤醒所有线程池中的线程了，只唤醒对方的一个线程，这样效率就高很多了
         }finally{
             lock.unlock();
         }
     }

     public void out(){
         lock.lock();
         try{
             while(!flag)
                 try{Consumer_con.await();}catch(Exception e){}
             System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);

             flag = true;
             //con.signalAll();

             Producer_con.signal();
         }finally{
             lock.unlock();
         }
     }
 }

 class Producer implements Runnable{
     private Resource r;
     Producer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.set("烤鸭");
         }
     }
 }

 class Consumer implements Runnable{
     private Resource r;
     Consumer(Resource r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.out();
         }
     }
 }

wait和sleep的区别：

wait和sleep都是让线程处于冻结状态的方法
区别:
　　1.wait可以指定时间也可以不指定。sleep必须指定时间。
　　2.在同步中时，对CPU的执行权和锁的处理不同.wait：释放执行权，释放锁。sleep：释放执行权，不释放锁（不同中的代码必须拿到锁才能运行）

　　3.wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）
   　　synchronized(x){
      　　　　x.notify()
     　　　　//或者wait()
   　　}
      4.sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常