并发编程学习笔记（十四、AQS同步器源码解析3，Lock & Condition & AQS）

目录：

• Lock & Condition & AQS使用示例
• Lock & Condition & AQS结构简述
• Lock与Condition的API解析

Lock & Condition & AQS使用示例

在说Lock和Condition之前我们先来看一下这两个的用法，从用法到源码，一步一步来。

public class ConditionDemo {

    /**
     * 创建独占锁
     */
    private ReentrantLock lock = new ReentrantLock();

    /**
     * 创建条件1
     */
    private Condition condition1 = lock.newCondition();

    /**
     * 创建条件2
     */
    private Condition condition2 = lock.newCondition();

    /**
     * 创建条件3
     */
    private Condition condition3 = lock.newCondition();

    /**
     * 日期格式化
     */
    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:MM:ss");

    public static void main(String[] args) throws InterruptedException {
        ConditionDemo conditionDemo = new ConditionDemo();
        Thread1 thread1 = conditionDemo.new Thread1();
        Thread2 thread2 = conditionDemo.new Thread2();
        Thread3 thread3 = conditionDemo.new Thread3();

        // Alibaba Java Coding Guidelines plugin 插件提示不要直接使用Executors
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(thread1);
        executorService.execute(thread2);
        executorService.execute(thread3);
        Thread.sleep(2000);

        // 依次唤醒各线程任务.
        signalTest(conditionDemo);
        executorService.shutdown();
    }

    /**
     * 依次唤醒各线程任务,以观察condition的作用
     *
     * @param conditionDemo ConditionDemo对象
     * @throws InterruptedException 中断异常
     */
    public static void signalTest(ConditionDemo conditionDemo) throws InterruptedException {
        // 创建独占锁 唤醒condition1的线程
        conditionDemo.lock.lock();
        conditionDemo.condition1.signal();
        // 释放独占锁 等待thread1执行完毕.
        conditionDemo.lock.unlock();
        Thread.sleep(2000);

        // 创建独占锁 唤醒condition2的线程
        conditionDemo.lock.lock();
        conditionDemo.condition2.signal();
        // 释放独占锁 等待thread2执行完毕.
        conditionDemo.lock.unlock();
        Thread.sleep(2000);

        // 创建独占锁 唤醒condition3的线程
        conditionDemo.lock.lock();
        conditionDemo.condition3.signal();
        // 释放独占锁 等待thread2执行完毕.
        conditionDemo.lock.unlock();
        Thread.sleep(2000);
    }

    /**
     * 线程任务定义类
     */
    public class Thread1 implements Runnable {

        public Thread1() {
        }

        @Override
        public void run() {
            try {
                // 设置线程名称
                Thread.currentThread().setName(Thread1.class.getSimpleName());
                System.out.printf("%s线程启动
", Thread.currentThread().getName());
                lock.lock();
                // 在condition1上阻塞，并且释放独占锁lock.
                condition1.await();
                System.out.printf("%s线程被唤醒", Thread.currentThread().getName());
                printDate();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {
                lock.unlock();
            }
        }
        
    }

    /**
     * 线程任务定义类
     */
    public class Thread2 implements Runnable {

        public Thread2() {
        }

        @Override
        public void run() {
            try {
                Thread.currentThread().setName(Thread2.class.getSimpleName());
                System.out.printf("%s线程启动
", Thread.currentThread().getName());
                lock.lock();
                // 在condition2上阻塞，并且释放独占锁lock.
                condition2.await();
                System.out.printf("%s线程被唤醒", Thread.currentThread().getName());
                printDate();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {
                lock.unlock();
            }
        }
        
    }

    /**
     * 线程任务定义类
     */
    public class Thread3 implements Runnable {

        public Thread3() {
        }

        @Override
        public void run() {
            try {
                Thread.currentThread().setName(Thread3.class.getSimpleName());
                System.out.printf("%s线程启动
", Thread.currentThread().getName());
                lock.lock();
                // 在condition3上阻塞，并且释放独占锁lock.
                condition3.await();
                System.out.printf("%s线程被唤醒", Thread.currentThread().getName());
                printDate();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {
                lock.unlock();
            }
        }
        
    }

    /**
     * 打印时间
     */
    void printDate() {
        System.out.println("【当前时间：" + simpleDateFormat.format(new Date()) + "】");
    }
    
}

上面代码看似很多单其实逻辑非常简单，只展示了Lock及Condition的基本用法：

• 首先我们创建一个Lock的可重入锁子类ReentrantLock，以及三个Condition执行条件。
• 然后我们为ConditionDemo构建了三个线程，每个线程都会先去从ReentrantLock获取锁，然后被对应的Condition阻塞，最后完成逻辑后释放锁。
• 最后通过signalTest()函数依次唤醒各线程的任务，其中会先通过lock.lock()获取资源，然后通过condition1.signal()通知对应的线程可执行，最后通过lock.unlock()释放锁。

通过上述代码，你可以了解到Condition可阻塞线程的执行（await()），然后满足条件后通知线程可执行（signal()）。

这里需要注意的是，Lock一般和Condition配合使用。

Lock & Condition & AQS结构简述

通过上述demo，你应该简单了解到了Lock与Condition的基本用法了，现在我们来看看它们的类结构，更进一步知晓它们。

通过ReentrantLock构造函数我们可以了解其根据NonfairSync实现，NonfairSync根据Sync实现，Sync又是根据我们熟悉的AQS实现；并且ReentrantLock是实现了Lock接口的。

而Condition的话同理可得出，其实现类为ConditionObject，其为AQS的内部类，java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject。

由此可得出如下类图：

Lock与Condition的API解析

在学习Lock及Condition的API之前，我们先回想下Lock及Condition的作用，分别是对资源的加锁，以及让线程阻塞，等待通知后再执行。

emmmmm，那这不就synchronize以及Object对象的wait、notify嘛(⊙o⊙)…，的确很相似，哈哈。

的确在大多数情况下，内置锁（synchronize）都能很好的工作，但它在功能上存在一些局限性，例如无法实现非阻塞结构的加锁规则等。

而Lock以及Condition的出现正是为了解决这一问题，它实现了可定时、可轮询与可中断的锁获取操作，公平队列，以及非块结构的锁。

注意：

• 与内置锁不同，Lock是一种显式锁，它更加危险，因为在程序离开被锁保护的代码块时，不会像监视器锁那样自动释放，需要我们手动释放锁。
• 所以在使用Lock时，一定要记得手动释放锁（lock.unlock()）。

——————————————————————————————————————————————————————————————————————

该说的都说了接下来我们来熟悉下Lock与Condition的API。

1、Lock：

public interface Lock {

    /**
     * 阻塞式获取锁。未获取到时线程会被阻塞，不会参与线程调度，直到获取到锁为止；获取锁的过程中不响应中断。
     */
    void lock();

    /**
     * 阻塞式获取锁。在以下两种情况下可中断锁，并抛出InterruptedException，抛出后会清除中断标志位
     * 1、调用方法时，中断标志位已经设置为true了
     * 2、在获取锁时线程被中断了，并且获取锁的实现会响应这个中断
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 非阻塞式获取锁。无论成功与否都会理解返回，获取成功返回true，反之false
     */
    boolean tryLock();

    /**
     * 同tryLock()，但带有超时机制，并且可中断。
     * 
     * 若获取到锁立即返回true，反之线程会休眠，直到满足一下三个条件之一：
     * 1、获取到锁
     * 2、其它线程中断了当前线程
     * 3、设定的超时时间到了
     * 若超时时间到了，还未获取锁，则会返回false。注意，这里超时并不会抛出异常
     * 
     * 中断的情况和lockInterruptibly()一致
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 释放锁，这里需要注意的是，只有拥有锁的线程才能释放锁，而且必须显示的释放锁。
     */
    void unlock();

    /**
     * 创建一个Condition条件对象
     */
    Condition newCondition();
    
}

2、Condition：

上面我们看到了Lock的最后一个方法newCondition()，由此方法便可以的出Condition是与Lock绑定的，而且他们还是一个一对多的关系。

那么我们来看下Condition是对象什么：

首先，一个新工具的出现肯定是为了解决某方面的问题的，如果说Lock是为了扩展现有的监视器锁，那么Condition肯定就是对wait、notify的延伸了。

——————————————————————————————————————————————————————————————————————

在说Condition API之前，我觉得我有必要说明下wait、notify的弊端，这样一方面能让你了解到wait、notify为啥在项目中不常见了，另一方面你可以更好的了解Condition的工作原理。

首先，我们调用wait方法的原因通常是线程有一定的条件不满足，我们才会去让其等待。其次，所有调用了wait方法的线程都会在同一个wait set中等待，嗯嗯这看上去很合理。

但这正式这一机制的短板之处，因为每一个wait的线程其实都是在等待同一个notify或notifyAll方法来唤醒自己，这就会导致自己可能会被别的线程的notify方法唤醒。

然而我们知道每个线程的执行条件肯定是不一样的，故会导致我虽然抢到资源取执行逻辑了，但却会发现自己依然不满足执行条件，然后就又wait了。

这无疑使一个浪费CPU资源的操作，所以说最好的方式就是每个线程知道自己在wait什么条件，这样notify的时候也不会唤醒别的线程，这就是Condition的做法。

——————————————————————————————————————————————————————————————————————

Condition的起源介绍完了，最后我们只要说下其API就可以了，其实非常简单，我相信你一下就能看出来其用法：

public interface Condition {

    void await() throws InterruptedException;

    void awaitUninterruptibly();

    long awaitNanos(long nanosTimeout) throws InterruptedException;

    boolean await(long time, TimeUnit unit) throws InterruptedException;

    boolean awaitUntil(Date deadline) throws InterruptedException;

    void signal();

    void signalAll();
    
}

从方法定义上就可以非常明了的知道，我们按照顺序类推：

• await()，线程等待
• 等待，但不响应中断
• 等待相应时间，纳秒单位
• 等待相应时间，自定义单位
• 等待到指定时间
• 唤醒线程
• 唤醒所有线程

哈哈是不是非常明了。

嗯~~~，说完了Condition之后是不是觉得它和Object的wait、notify非常想，是的非常想，所以我们最后来总结下。