java学习之多生产者和多消费者

在上一节当中我们说道了，java多线程当中单个消费者对应单个生产者的关系。这个时候有几个点需要注意一下，第一个就是把if判断flag的语句改成while这样能够避免，比如如果我们这个时候用if的话判断完为真之后，线程就睡过去了，但是当下一次线程notify的时候，这个时候生产者还有消费者，也就是一个锁上面的线程拥有线程苏醒的机会是等同的。这个时候，如果生产者冻结之后，紧接着notify的话这个时候苏醒的还可能是生产者，这是我们不愿意看到的。那我们应该如何来处理呢，这个时候我们就应该把if改成while因为while是个循环，当下一次该线程苏醒的时候还应到回过头来判断，flag标记，这样就避免了生产者自我唤醒的这种情况。

但是现在问题变了，就是这个时候有多个生产者还有多个消费者，我们知道当只有一个生产者还有一个消费者的时候，至少会唤醒其中的一个，那么要是多个生产者还有多个消费者呢，我们可以这样想一下，比如说这个时候有两个生产者A和B，还有两个消费者C和D，此时A生产完了之后，这个时候A就开始唤醒了，假如A唤醒了C这个时候C开始生产消费产品，消费完了之后开始通知其他线程，这个时候假如被唤醒的是D线程，因为flag是假的证明已经没有东西可消费了，这个时候他又冻结。那么这个时候其他线程就都被冻结了，这个时候就形成了死锁现象，如果要避免死锁现象的话，java又为我们提供了一个方法，叫做notifyAll()方法，这个方法的作用在于能够把所有的线程都唤醒，这样就能保证消费者还有生产者至少可以唤醒双方的一个线程，保证程序的正常运行。这样做的一个缺点就是其中还有一个属于己方的线程被唤醒，这样就浪费了资源。于是在jdk更新的时候，就为我们提供了一个新的api能够显式的来操作锁还有唤醒冻结线程，这个线程不再核心lang包当中，这个api在java.util.concurrent.locks这个包当中为我们提供了两个接口，一是Lock接口还有一个是Condition接口。Lock接口扩展的方法有lock()方法还有一个unlock方法，这里需要注意的一点是，无论如何一定要释放锁，这个时候就用到了前面异常所讲到的finally语句，无论如何一定要执行。Lock当中还扩展了一个方法就是newCondition()这个方法，这个方法的作用是给一个锁定义多个消息传递的方式也就是给线程绑定多个监视器，比如说生产者只唤醒消费者的线程，而不唤醒生产者的线程，同理消费者也是如此。同时在Lock当中等待的方法不是wait()方法，唤醒的方法也不是notify()方法,这两个方法分别对应Lock当中的await()方法和signal()方法。

我们综合上面所讲来用代码体现下：

 import java.util.concurrent.locks.*;
 class KaoYa
 {

     int num = ;

     Lock l = new ReentrantLock();

     Condition c1 = l.newCondition();
     Condition c2 = l.newCondition(); 

     boolean flag;

     public void produce() throws InterruptedException
     {
             l.lock();

             try{
                 while(true)
                 {
                     while(flag)
                         c1.await();
                         System.out.println(Thread.currentThread().getName()+"KaoYa...."+num);
                         flag = true;
                         c2.signal();
                 }        //num++;

             }finally
             {
                 l.unlock();
             }
     }

     public void consume() throws InterruptedException
     {
         l.lock();

             try{
                 while(true)
                 {
                     while(!flag)
                         c2.await();
                     System.out.println(Thread.currentThread().getName()+"KaoYa------"+num);
                     num++;
                     flag = false;
                     c1.signal();
                 }
             }finally
             {

                 l.unlock();

             }
     }

 }

 class Product implements Runnable
 {

     KaoYa k;
     Product(KaoYa k)
     {

         this.k = k;

     }

     public void run()
     {
         try{
             k.produce();
         }catch(InterruptedException e)
         {

         }
     }
 }

 class Consume implements Runnable
 {

     KaoYa k;
     Consume(KaoYa k)
     {

         this.k = k;

     }

     public void run()
     {

         try{
             k.consume();
         }catch(InterruptedException e)
         {

         }

     }

 }

 class LockDemo
 {

     public static void main(String[] args) {

         KaoYa k = new KaoYa();
         Product p = new Product(k);
         Consume c = new Consume(k);

         Thread t1 = new Thread(p);
         Thread t2 = new Thread(p);
         Thread t3 = new Thread(c);
         Thread t4 = new Thread(c);

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

     }

 }