一线大厂面试真题，模拟消费者-生产者场景。

      同样今天的分享，我们不纸上谈兵，也不空谈八股文。以实际面经、工作实战经验进行开题，然后再剖析核心源码原理。

      按常见面经要求，生产者生产完指定数量产品后，才能消费。消费者消费完这批产品后，生产者才能继续生产。

      我们利用Condition可以协调线程之间的通知执行和阻塞等待特性，进行实现经典的【生产者-消费者】场景。代码有详细描述，用最少代码演示，尽力让大家看一遍就能懂、能复用。

package lading.java.mutithread;

import cn.hutool.core.date.DateTime;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 模拟生产者-消费者，生产者生产了产品后消费者才能消费，消费者消费完产品后才能继续生产产品
 * 每次随机最多生产4件产品，消费者消费完才能继续生产
 */
public class Demo011Condition {
    //可消费的产品数量
    public static AtomicInteger productNum = new AtomicInteger(0);
    //可重入锁
    public static ReentrantLock lock = new ReentrantLock();
    //消费者信号
    public static Condition consumer = lock.newCondition();
    //生产者信号
    public static Condition producer = lock.newCondition();

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    //如果有产品可以消费
                    while (productNum.get() > 0) {
                        //生产者线程阻塞等待,并释放锁
                        producer.await();
                    }
                    //随机生产最多4件产品，耗时3s
                    Thread.sleep(3000);
                    int total = new Random().nextInt(4) + 1;
                    for (int i = 0; i < total; i++) {
                        System.out.println(DateTime.now().toString("YYYY-MM-dd hh:mm:ss SSS") + " 【" + Thread.currentThread().getName() + "】新生产了产品:" + productNum.incrementAndGet());
                    }
                    //通知消费者来消费
                    System.out.println("生产者 --> 已生产" + total + "件产品，可以过来消费。");
                    consumer.signalAll();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }

        }, "生产者").start();

        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    //没有可以消费，消费者进入阻塞等待，释放锁
                    while (productNum.get() == 0) {
                        consumer.await();
                    }
                    //消费者消费产品,耗时2s
                    Thread.sleep(2000);
                    int total = productNum.get();
                    while (productNum.get() != 0) {
                        System.out.println(DateTime.now().toString("YYYY-MM-dd hh:mm:ss SSS") + " 【" + Thread.currentThread().getName() + "】消费了产品:" + productNum.getAndDecrement());
                    }
                    //唤醒生产者继续生产
                    System.out.println("消费者 --> " + total + "件产品已清空，请继续生产。");
                    producer.signalAll();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "消费者").start();
    }
}

结果，消费者和生产者交叉运行。

生产好了产品，通知消费者消费；

消费者消费完产品，通知生产者继续生产产品。

1、Condition是什么？

Condition很简单，它只是JUC包里的一个接口。定义了2个核心方法。

一个是await()方法，可以让线程进入阻塞等待。

另一个是signal()方法，可以唤醒指定线程。

1.1 具体看看Condition源码

在AQS的内部类ConditionObject对这个接口进行了实现。我们看ConditionObject，他就是AQS里经典的FIFO条件等待队列。

ConditionObject的类结构图。

看了源码结构，和刚才总结一样，Condition有2大核心方法：

其中，await()，还有一个阻塞等待时间入参可选await(long time, TimeUnit unit)：让当前线程进入阻塞，等待该条件唤醒，并设置等待超时时间；

然后signal()是唤醒等待该Condition的一个线程；而signalAll()是唤醒所有等待该Condition条件的线程。

2、Condition的条件等待唤醒和Object.wait()、notify()有什么区别

      问到正主了，其实这个问题也就是问：Condition的优点有哪些。最开始我们学JAVA编程，都是从synchronized开始，线程并发协调，常用的就是对象的wait(),nofity()方法。

     说到Condition的条件等待和唤醒，与JAVA对象的等待唤醒机制区别，就应该先说说ReentrantLock和synchronized的区别。这个区别在之前的文章《ReentrantLock核心原理剖析》有过分享。这里再补充几个。其中之一，就是ReentrantLock通过Condition条件队列实现多路通知，而synchronized只能单路通知。具体就是ReentrantLock可以通过多个不同的condition条件队列进行等待和唤醒，synchronized相当于功能单一的锁。

另外synchronized的锁是通过JVM实现，而ReentrantLock是通过接口api实现。

那Condition条件队列和对象的等待阻塞最大不同是什么？

一句话：Condition支持按顺序精准唤醒线程。而Object的做不到。

      比如要求实现A和B执行完成后，C才能执行，而且C执行完成后才能执行D、F。任意指定协调条件，Condition都可以支持。

篇幅有限，这个精准唤醒多条件协调案例demo先不放上来了。

3、说说Condition条件队列核心原理

      那我们就说说await()方法是如何实现的，一句话，核心就是：调用await()方法后，当前线程进入阻塞，同时释放锁。

具体我们看看源码。

        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            //将自己加入到AQS的FIFO等待队列尾部，进入等待    
            Node node = addConditionWaiter();
            //释放锁资源
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            //检测本线程节点是否在AQS同步队列中，如果不在就继续检测，直到发现在AQS同步队列中
            while (!isOnSyncQueue(node)) {
                //如果在队列中，就挂起本线程
                LockSupport.park(this);
                //如果被中断，则跳出循环
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //尝试获取锁-毕竟这期间有可能被唤醒了，以及是否发生过中断
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

具体await()方法里，就是线程进入了阻塞状态，以及自旋，不断判断自己NODE节点是在等待队列，还是在AQS队列。如果在AQS队列，就说明已经被唤醒了，不用再继续阻塞。如果还在等待队列，就继续自旋。

最后，我们再看看signal()唤醒方法。唤醒该条件队列线程。如果ReentrantLock是公平锁，就唤醒等待时间最长的头节点线程，如果是非公平锁，就唤醒整个等待队列。

唤醒操作，其实就是从等待队列中，将头节点挪到AQS节点，这样这个节点就被唤醒，不用再阻塞。如果是signalAll()，就是将全部等待队列节点，挪到AQS，唤醒他们。

        public final void signal() {
            //判断当前线程是否持有锁，只有持有锁才能唤醒其他线程，不持有锁，就抛异常
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }
        //具体唤醒过程
        private void doSignal(Node first) {
            //尝试将头节点NODE唤醒，从等待队列中，挪到AQS队列，并通过CAS操作更新NODE状态
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

今天就分享这么多，目前已分享synchronized、volatile、AQS、CAS、ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier、Condition,并发编程里的基础中的基础已经分享完了.

下次我们分享线程池、并发容器、ThreadLocal、Future、FutureTask。