java ReentrantLock结合条件队列 实现生产者-消费者模式 以及ReentratLock和Synchronized对比

 package reentrantlock;

 import java.util.ArrayList;

 public class ProviderAndConsumerTest {

     static ProviderAndConsumer providerAndConsumer  =  new ProviderAndConsumer();

     public static void main(String[] args) throws InterruptedException {

 //        new Thread(new GetRunnable(), "消费者002").start();
 //        Thread.sleep(1000);
 //        new Thread(new PutRunnable(), "生产者001").start();

         ArrayList<Thread> provider = new ArrayList<>();
         for (int i = 0; i < 3; i++){
             provider.add(new Thread(new PutRunnable(), "生产者00"+ (i+1)));
         }

         ArrayList<Thread> consumer = new ArrayList<>();
         for (int i = 0; i < 3; i++){
             consumer.add(new Thread(new GetRunnable(), "      消费者--99"+ (i+1)));
         }

         for (Thread i :
                 consumer) {
             i.start();
         }

         // 先让消费者线程全部饥饿，进入消费者条件队列中
         Thread.sleep(10000);

         for (Thread i :
                 provider) {
             i.start();
         }

     }

     static class PutRunnable implements Runnable {

         @Override
         public void run() {
             for (int i = 0; i < 3; i++){
                 providerAndConsumer.put("   (" +Thread.currentThread().getName() + "_data_" + i + ")");
                 try {
                     // 调整睡眠时间，等同于调整生产者生产数据的频率，但是不准，因为跟生产者内部逻辑执行时间有很大关系
                     Thread.sleep(500,1);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }
     }

     static class GetRunnable implements Runnable{

         @Override
         public void run() {
             while(true){
                 providerAndConsumer.get();
                 try {
                     // 调整睡眠时间，等同于调整消费者消费数据的频率，但是不准，因为跟消费者内部执行时间有很大关系
                     Thread.sleep(10,1);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }

 package reentrantlock;

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

 public class ProviderAndConsumer {

     ReentrantLock reentrantLock = new ReentrantLock();
     Condition notEmpty = reentrantLock.newCondition();
     Condition notFull = reentrantLock.newCondition();
     int maxSize = 3;
     int putIndex = 0;
     int getIndex = 0;
     int realDataCount = 0;
     Object[] queue = new Object[maxSize];

     boolean isConsumerWait = false;
     boolean isProviderWait = false;

     public void put(Object data){
         System.out.println(Thread.currentThread().getName() + "线程，-----尝试加锁-----");
         reentrantLock.lock();
         System.out.println(Thread.currentThread().getName() + "线程，-----加锁成功-----");
         try {

             while (realDataCount == queue.length){
                 System.out.println(Thread.currentThread().getName() + "线程，-----数据满了，只好等待----" +
                         "哈哈要进生产者条件队列啦");
                 isProviderWait = true;
                 notFull.await();
             }

             queue[putIndex] = data;
             realDataCount++;

             putIndex++;
             if (putIndex == queue.length) putIndex = 0;
             System.out.println(Thread.currentThread().getName() + "线程，成功生产一个数据=" + data.toString());

             if (isConsumerWait){
                 System.out.println(Thread.currentThread().getName() + "线程，" +
                         " 未 激活消费者条件队列节点前，获取消费者队列长度"
                         + reentrantLock.getWaitQueueLength(notEmpty));
             }
             notEmpty.signal();
             if (isConsumerWait){
                 int length = reentrantLock.getWaitQueueLength(notEmpty);
                 if (length == 0){
                     isConsumerWait = false;
                 }
                 System.out.println(Thread.currentThread().getName() + "线程，" +
                         " 已 激活消费者条件队列节点后，获取消费者队列长度"
                         + reentrantLock.getWaitQueueLength(notEmpty));
             }
             // 调整睡眠时间，等同于调整生产者持有锁的时间
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             System.out.println(Thread.currentThread().getName() + "线程，成功解锁");
             reentrantLock.unlock();
         }

     }

     public void get(){
         System.out.println("\t\t" + Thread.currentThread().getName() + "线程，尝试加锁");
         reentrantLock.lock();
         System.out.println("\t\t" + Thread.currentThread().getName() + "线程，-----加锁成功----");

         try {

             while (realDataCount == 0){
                 System.out.println("\t\t" + Thread.currentThread().getName() + "线程，-----没有数据，只好等待----"+
                         "哈哈 要进消费者条件队列啦");
                 isConsumerWait = true;
                 notEmpty.await();
             }

             System.out.println("\t\t" + Thread.currentThread().getName() + "线程，成功消费一个数据=" + queue[getIndex]);
             realDataCount--;

             getIndex++;
             if (getIndex == queue.length) getIndex = 0;

             if (isProviderWait){
                 System.out.println("\t\t" + Thread.currentThread().getName() + "线程，" +
                         " 未 激活生产者条件队列节点前，获取生产者队列长度"
                         + reentrantLock.getWaitQueueLength(notFull));
             }
             notFull.signal();
             if (isProviderWait){
                 int length = reentrantLock.getWaitQueueLength(notFull);
                 if (length == 0){
                     isProviderWait = false;
                 }
                 System.out.println("\t\t" + Thread.currentThread().getName() + "线程，" +
                         " 已 激活生产者条件队列节点后，获取生产者队列长度"
                         + length);
             }

         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             System.out.println("\t\t" + Thread.currentThread().getName() + "线程，成功解锁");
             reentrantLock.unlock();
         }
     }

 }

跑通上面的例子可以得到一些总结：

1、在生产者-消费者模式下，消费者线程和生产者线程都在抢占cpu，谁抢到cpu谁就得到执行。抢不到的会进入AQS队列。
　　此时如果有多个线程在抢占不到cpu进入AQS队列时，进入AQS队列的顺序是不可预知的（比如恰好经历线程切换），
　　但可以保证的是: 一旦在AQS队列里，顺序就是绝对从前往后的。
　　换句话说，先尝试获取锁的线程在获取不到锁需要进入AQS队列时，不一定就比其他紧接着（也就是说几乎同时，但相对靠后）
　　尝试获取锁同样获取不到锁需要进入AQS队列要进入队列早。（比如恰好经历线程切换）

2、那什么时候会进入条件队列呢？什么时候出条件对列呢？
　　当消费者线程获取到cpu，但此时，没有任何数据可供消费，那么当前的这个消费者线程就会释放（完全释放，因为是可重入）锁并让出cpu资源（线程挂起）然后进入消费者条件队列
　　当接下来有生产者线程得到cpu执行并生产出数据后，生产者线程就会唤醒“消费者条件队列”中的第一个线程，并把第一个线程加入到AQS队列的尾部
　　对于“生产者条件对列”，跟上面是一个道理。
3、生产者-消费者模式中的数据缓存区，有一个生产者生产指针，指向下一个生产数据应该放的位置，有一个消费者消费指针，指向下一个要消费的数据的位置。
4、永远记住，锁只是一种资源控制方式，任何行为都不能控制cpu在何时切换，以及cpu切换到哪个线程。

ReentratLock和Synchronized对比：
相同点：

1、都是独占锁。synchronized属于隐式锁，编码简单。ReentrantLock需要手动控制加锁解锁，必须配对使用，控制灵活，但是相对技术要求高。
2、都具有可重入性。synchronized可重入简单，用在复杂场景中（比如递归）不需要考虑锁释放的问题。ReentrantLock手动控制，必须配对，在复杂场景中，对技术要求高，否则带来锁不能正确释放的问题。

不同点：

1、灵活性。synchronized属于非公平锁，cpu切换到哪个线程，哪个线程就获得执行。ReentrantLock可灵活配置公平锁、非公平锁。
2、是否可被中断。synchronized不可被中断，一直阻塞。ReentrantLock可被中断，更好的用于解决死锁问题。
3、ReentrantLock使用场景更多。可设置超时时间。可结合条件队列实现 等待-通知机制（例如生产者-消费者模式）