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("		" + Thread.currentThread().getName() + "线程，尝试加锁");
        reentrantLock.lock();
        System.out.println("		" + Thread.currentThread().getName() + "线程，-----加锁成功----");

        try {

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

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

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

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

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("		" + 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使用场景更多。可设置超时时间。可结合条件队列实现 等待-通知机制（例如生产者-消费者模式）