了解这两个接口后，阿里多线程面试题秒AC --20210715

大家好，我是指北君

我们知道，阿里面试时非常喜欢考Java多线程编程题，如果你AC不了，可能会给面试官留下一个基础不扎实的印象，影响到你offer的收割，想当年指北君面阿里时就因为秒AC了一道多线程面试题，让面试官刮目相看，所以我们需要重视Java多线程编程。

一般在解决多线程编程题时，我们都离不开JUC并发包下的各种工具类，特别是ReentrantLock锁，它能提供互斥与线程同步的能力，那它是如何获得这个能力的呢？今天指北君就来详细说说给它提供强大能力的两大接口。（PS：文末有当年指北君面试阿里的多线程编程原题以及答案喔）

我们知道，并发领域中有两大核心问题：互斥与同步问题，Java在1.5版本之前，是提供了synchronized来实现的。synchronized是内置锁，虽然在大部分情况下它都能很好的工作，但是依然还是会存在一些局限性，除了当时1.5版本的性能问题外（1.6版本后，synchronized的性能已经得到了很大的优化），还有如下两个问题：

1. 无法解决死锁问题
2. 最多使用一个条件变量

所以针对这些问题，Doug Lea在并发包中增加了两个接口Lock和Condition来解决这两个问题，所以指北君今天就说说这两个接口是如何解决synchronized中的这两个问题的。

一. Lock接口

1.1 介绍

在我们分析Lock接口是如何解决死锁问题之前，我们先看看死锁是如何产生的。死锁的产生需要满足下面四个条件：

1. 互斥：共享资源同一时间只能被一个线程占用
2. 不可抢占：其他线程不能强行占有另一个线程的资源
3. 占有且等待：线程在等待其他资源时，不释放自己已占有的资源
4. 循环等待：线程1和线程2互相占有对方的资源并相互等待

所以，我们只需要破坏上面条件中的任意一个，即可打破死锁。但需要注意的是，互斥条件是不能破坏的，因为使用锁的目的就是为了互斥。所以Lock接口通过破坏掉 “不可抢占”这个条件来解决死锁，具体如下：

1. 非阻塞获取锁：尝试获取锁，如果失败了就立刻返回失败，这样就可以释放已经持有的其他锁

2. 响应中断：如果发生死锁后，此线程被其他线程中断，则会释放锁，解除死锁

3. 支持超时：一段时间内获取不到锁，就返回失败，这样就可以释放之前已经持有的锁

接下来我们具体看看接口代码吧。

1.2 源码解读

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

public interface Lock { /** 阻塞获取锁，不响应中断，如果获取不到，则当前线程将进入休眠状态，直到获得锁为止。 */ void lock(); /** 阻塞获取锁，响应中断，如果出现以下两种情况将抛出异常 1.调用该方法时，此线程中断标志位被设置为true 2.获取锁的过程中此线程被中断，并且获取锁的实现会响应中断 */ void lockInterruptibly() throws InterruptedException; /** 非阻塞获取锁，不管成功还是失败，都会立刻返回结果，成功了返回true,失败了返回false */ boolean tryLock(); /** 带超时时间且响应中断的获取锁，如果获取锁成功，则返回true,获取不到则会休眠，直到下面三个条件满足 1.当前线程获取到锁 2.其他线程中断了当前线程，并且获取锁的实现支持中断 3.设置的超时事件到了 而抛出异常的情况与lockInterruptibly一致 当异常抛出后中断标志位会被清除，且超时时间到了，当前线程还没有获得锁，则会直接返回false */ boolean tryLock(long time, TimeUnit unit) throws InterruptedException; /** 没啥好说，只有拥有锁的线程才能释放锁 */ void unlock(); /** 返回绑定到此Lock实例的新Condition实例。 在等待该条件之前，该锁必须由当前线程持有。调用Condition.await（）会在等待之前自动释放锁，并在等待返回之前重新获取该锁。 我们再下一小节再详细说说Condition接口 */ Condition newCondition(); }

还需要额外注意的一点，使用synchronized作为锁时，我们是不需要考虑释放锁的，但Lock是属于显示锁，是需要我们手动释放锁的。我们一般在finally块中调用lock.unlock()手动释放锁，具体形式如下：

1 2 3 4 5 6 7

Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }

我们最后通过一张图来总结下Lock接口：

二. Condition接口

2.1 介绍

针对synchronized最多只能使用一个条件变量的问题，Condition接口提供了解决方案。但是为什么多个条件变量就比一个条件变量好呢？我们先来看看synchronized使用一个条件变量时会有什么弊端。

一个synchronized内置锁只对应一个等待容器（wait set），当线程调用wait方法时，会把当前线程放入到同一个等待容器中，当我们需要根据某些特定的条件来唤醒符合条件的线程时，我们只能先从等待容器里唤醒一个线程后，再看是否符合条件。如果不符合条件，则需要将此线程继续wait，然后再去等待容器中获取下一个线程再判断是否满足条件。这样会导致许多无意义的cpu开销。

我们可以看到Lock接口中有个newCondition()的方法:

1	Condition newCondition();

通过这个方法，一个锁可以建立多个Conditiion，每个Condtition都有一个容器来保存相应的等待线程，拿到锁的线程根据特定的条件唤醒对应的线程时，只需要去唤醒对应的Contition内置容器中的线程即可，这样就可以减少无意义的CPU开销。然后我们具体看看Condition接口的源码。

2.2 源码解读

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

public interface Condition { /** 使当前线程等待，并响应中断。当当前线程进入休眠状态后，如果发生以下四种情况将会被唤醒： 1.其他一些线程对此条件调用signal方法，而当前线程恰好被选择为要唤醒的线程； 2.其他一些线程对此条件调用signalAll方法 3.其他一些线程中断当前线程，并支持中断线程挂起 4.发生“虚假唤醒”。 */ void await() throws InterruptedException; /** 使当前线程等待，并不响应中断。只有以下三种情况才会被唤醒 1.其他一些线程对此条件调用signal方法，而当前线程恰好被选择为要唤醒的线程； 2.其他一些线程对此条件调用signalAll方法 3.发生“虚假唤醒”。 */ void awaitUninterruptibly(); /** 使当前线程等待，响应中断，且可以指定超时事件。发生以下五种情况之一将会被唤醒： 1.其他一些线程为此条件调用signal方法，而当前线程恰好被选择为要唤醒的线程； 2.其他一些线程为此条件调用signalAll方法； 3.其他一些线程中断当前线程，并且支持中断线程挂起； 4.经过指定的等待时间； 5.发生“虚假唤醒”。 */ long awaitNanos(long nanosTimeout) throws InterruptedException; /** 与awaitNanos类似，时间单位不同 */ boolean await(long time, TimeUnit unit) throws InterruptedException; /** 与awaitNanos类似，只不过超时时间是截止时间 */ boolean awaitUntil(Date deadline) throws InterruptedException; /** 唤醒一个等待线程 */ void signal(); /** 唤醒所有等待线程 */ void signalAll(); }

需要注意的是，Object类的等待方法是没有返回值的，但Condtition类中的部分等待方法是有返回值的。awaitNanos(long nanosTimeout)返回了剩余等待的时间；await(long time, TimeUnit unit)返回boolean值，如果返回false，则说明是因为超时返回的，否则返回true。为什么增加返回值？为了就是帮助我们弄清楚方法返回的原因。

四. 阿里多线程考题

最后我们通过实现了Lock和Condition接口能力的ReentrantLock类来解决阿里多线程面试题。

题目是使用三个线程循环打印ABC，一共打印50次。我们直接上答案：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

public class Test { int count = 0; Lock lock = new ReentrantLock(); Condition conditionA = lock.newCondition(); Condition conditionB = lock.newCondition(); Condition conditionC = lock.newCondition(); public void printA() { while (count < 50) { try { // 加锁 lock.lock(); // 打印A System.out.println("A"); count ++; // 唤醒打印B的线程 conditionB.signal(); // 将自己放入ConditionA的容器中，等待其他线程的唤醒 conditionA.await(); } catch (InterruptedException e) { e.printStackTrace(); } finally { // 释放锁 lock.unlock(); } } } public void printB() { while (count < 50) { try { // 加锁 lock.lock(); // 打印B System.out.println("B"); count ++; // 唤醒打印C的线程 conditionC.signal(); // 将自己放入ConditionB的容器中，等待其他线程的唤醒 conditionB.await(); } catch (InterruptedException e) { e.printStackTrace(); } finally { // 释放锁 lock.unlock(); } } } public void printC() { while (count < 50) { try { // 加锁 lock.lock(); // 打印B System.out.println("C"); count ++; // 唤醒打印A的线程 conditionA.signal(); // 将自己放入ConditionC的容器中，等待其他线程的唤醒 conditionC.await(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } public static void main(String[] args) { Test test = new Test(); // 建立打印ABC的三个线程 Thread theadA = new Thread(() -> { test.printA(); }); Thread theadB = new Thread(() -> { test.printB(); }); Thread theadC = new Thread(() -> { test.printC(); }); // 启动线程 theadA.start(); theadB.start(); theadC.start(); } }

五. 总结

Lock与Condition接口就说完了，最后指北君再总结一下：

针对synchronized内置锁无法解决死锁、只有一个条件变量等问题，Doug Lea在Java并发包中增加了Lock和Condition接口来解决。对于死锁问题，Lock接口增加了超时、响应中断、非阻塞三种方式来获取锁，从而避免了死锁。针对一个条件变量问题，Condtition接口通过一把锁可以创建多个条件变量的方式来解决。最后我们通过一个阿里面试题来说明了Lock和Condition接口所提供的能力。

今天就到这了，我是指北君，我们下篇文章见~