JAVA（五）ReentrantLock(重入锁)+Condition 生产者消费者模型

重点：ReentrantLock+Condition，await、signal方法 VS synchronized+Object的wait、notify

1. ReentrantLock对比snchronized

 ReentrantLock支持公平锁和非公平锁、可中断。

// 非公平锁（默认）
final ReentrantLock lock = new ReentrantLock();
final ReentrantLock lock = new ReentrantLock(false);
// 公平锁
final ReentrantLock lock = new ReentrantLock(true);

synchronized只支持非公平锁，不可中断。

2. Condition的await，signal对比Object的wait、notify 

// Condition
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;

// Object
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException("nanosecond timeout value out of range");
    }
    if (nanos > 0) {
        timeout++;
    }
    wait(timeout);
}

await和wait的区别不是很大，关键在于ReentrantLock和synchronized的不同上。

3. 生产者消费者模型

代码：

static class producerAndConsumer{

    boolean flag = false;
    Lock lock = new ReentrantLock();
    Condition producerCon = lock.newCondition();
    Condition consumerCon = lock.newCondition();

    public void producer(){
        lock.lock();
        if(flag){
            System.out.println("还有食物，暂时不需要生产");
                try {
                    producerCon.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
        flag = true;
        System.out.println("生产者生产了食物");
        consumerCon.signal();
        lock.unlock();
    }

    public void consumer(){
        lock.lock();
        if(!flag){
            System.out.println("没有食物了,通知生产者生产");
            try {
                consumerCon.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费者进食中");
        flag = false;
        producerCon.signal();
        lock.unlock();
    }
    
    public static void main(String []args) throws Exception{
        producerAndConsumer pac = new producerAndConsumer();
        new Thread(()->{
            for(int i=0;i<3;i++)
            pac.producer();
        }).start();

        new Thread(()->{
            for(int i=0;i<3;i++)
            pac.consumer();
        }).start();
    }
}

生产者和消费者之间的同步冲突，采用lock+Condition解决。 
在定义好这两者之后，通过标志强化二者之间的同步标记。

在主函数中，对生产者和消费者各自调用三次。那么他们之间是如何同步的呢？

首先初始化两条线程后，这二者之间会有个竞争关系，也就是说，第一次的输出可能是消费者，也可能是生产者，各自50%的几率。

假如第一次是生产者拿到锁。 
消费者竞争失败，触碰到lock，会进入线程进入了AQS（Abstract-Queue-Synchronized）抽象同步队列。

成功的生产者拿到锁，这时生产者会生产食物。 
生产者然后通知消费者consumerCon.signal();， 
生产者其次释放锁lock.unlock();释放锁 
生产者立即重入（非公平锁）（注意我们一个线程有三次循环），但是这时会有标志提醒生产者 
System.out.println(“还有食物，暂时不需要生产”); 
producerCon.await();释放锁 
此时生产者进入Condition，条件等待队列（显然是在等signal）

苦等多时的消费者终于可以吃上饭了。 
获得锁后，吃完饭，重新进入与新的一轮，与生产者之间获取资源循环。

注释 
非公平锁是可重入的，即在释放资源后，只需对计时器satus+1，即可重新获得锁。

公平锁，按照进入等待队列的时间来分配锁的使用，等待时间长的优先。