疯狂架构师讲解最强：并发编程模式PDF篇，含并发编程面试及答案

2022-03-31 21:30·90后小伙的追梦之路

同步模式之保护性暂停

1.定义

即Guarded Suspension，用在一个线程等待另一个线程的执行结果要点
有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject
如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
JDK中，join的实现、Future的实现，采用的就是此模式
因为要等待另一方的结果，因此归类到同步模式

2.实现

应用
一个线程等待另一个线程的执行结果

执行结果

3.带超时版GuardedObject

如果要控制超时时间呢

测试，没有超时

输出

测试，超时

输出

原理之join
4.多任务版GuardedObject

图中Futures就好比居民楼一层的信箱（每个信箱有房间编号），左侧的t0，t2，t4就好比等待邮件的居民，右侧的t1，t3，t5就好比邮递员

如果需要在多个类之间使用GuardedObject对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理

新增id用来标识Guarded Object

中间解耦类

业务相关类

测试

某次运行结果

同步模式之Balking

1.定义

Balking（犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回

2.实现
例如：

当前端页面多次点击按钮调用start时
输出

它还经常用来实现线程安全的单例

对比一下保护性暂停模式：保护性暂停模式用在一个线程等待另一个线程的执行结果，当条件不满足时线程等待。

同步模式之顺序控制

1.固定运行顺序

比如，必须先2后1打印

1.1 wait notify版

1.2 Park Unpark版

可以看到，实现上很麻烦：

首先，需要保证先wait再notify，否则wait线程永远得不到唤醒。因此使用了『运行标记』来判断该不该wait

第二，如果有些干扰线程错误地notify了wait线程，条件不满足时还要重新等待，使用了while循环来解决此问题

最后，唤醒对象上的wait线程需要使用notifyAll，因为『同步对象』上的等待线程可能不止一个可以使用LockSupport类的park和unpark来简化上面的题目：

park和unpark方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』，不需要『同步对象』和『运行标记』
2.交替输出
线程1输出a 5次，线程2输出b 5次，线程3输出c 5次。现在要求输出abcabcabcabcabc怎么实现
2.1 wait notify版

2.2 Lock条件变量版

2.3 Park Unpark版

异步模式之生产者/消费者

1.定义

要点

与前面的保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应
消费队列可以用来平衡生产和消费的线程资源
生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
JDK中各种阻塞队列，采用的就是这种模式

2.实现

应用

某次运行结果

结果解读

异步模式之工作线程

1.定义
让有限的工作线程（Worker Thread）来轮流异步处理无限多的任务。也可以将其归类为分工模式，它的典型实现就是线程池，也体现了经典设计模式中的享元模式。

例如，海底捞的服务员（线程），轮流处理每位客人的点餐（任务），如果为每位客人都配一名专属的服务员，那么成本就太高了（对比另一种多线程设计模式：Thread-Per-Message）

注意，不同任务类型应该使用不同的线程池，这样能够避免饥饿，并能提升效率

例如，如果一个餐馆的工人既要招呼客人（任务类型A），又要到后厨做菜（任务类型B）显然效率不咋地，分成服务员（线程池A）与厨师（线程池B）更为合理，当然你能想到更细致的分工

2.饥饿

固定大小线程池会有饥饿现象
两个工人是同一个线程池中的两个线程
他们要做的事情是：为客人点餐和到后厨做菜，这是两个阶段的工作
客人点餐：必须先点完餐，等菜做好，上菜，在此期间处理点餐的工人必须等待
后厨做菜：没啥说的，做就是了
比如工人A处理了点餐任务，接下来它要等着工人B把菜做好，然后上菜，他俩也配合的蛮好
但现在同时来了两个客人，这个时候工人A和工人B都去处理点餐了，这时没人做饭了，饥饿

输出

当注释取消后，可能的输出

解决方法可以增加线程池的大小，不过不是根本解决方案，还是前面提到的，不同的任务类型，采用不同的线程池，例如：

输出

创建多少线程池合适

过小会导致程序不能充分地利用系统资源、容易导致饥饿

过大会导致更多的线程上下文切换，占用更多内存
3.1 CPU密集型运算
通常采用cpu核数+ 1能够实现最优的CPU利用率，+1是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证CPU时钟周期不被浪费
3.2 I/O密集型运算
CPU不总是处于繁忙状态，例如，当你执行业务计算时，这时候会使用CPU资源，但当你执行I/O操作时、远程RPC调用时，包括进行数据库操作时，这时候CPU就闲下来了，你可以利用多线程提高它的利用率。经验公式如下
线程数=核数*期望CPU利用率*总时间(CPU计算时间+等待时间) / CPU计算时间

例如4核CPU计算时间是50%，其它等待时间是50%，期望cpu被100%利用，套用公式

4 * 100% * 100% / 50% = 8

例如4核CPU计算时间是10%，其它等待时间是90%，期望cpu被100%利用，套用公式

4 * 100% * 100% / 10% = 40

自定义线程池

步骤1：自定义拒绝策略接口

步骤2：自定义任务队列

步骤3：自定义线程池

步骤4：测试

终止模式之两阶段终止模式

Two Phase Termination

在一个线程T1中如何“优雅”终止线程T2？这里的【优雅】指的是给T2一个料理后事的机会。
1.错误思路

使用线程对象的stop()方法停止线程
stop方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁

使用System.exit(int)方法停止线程
目的仅是停止一个线程，但这种做法会让整个程序都停止

2.两阶段终止模式

2.1利用isInterrupted

interrupt可以打断正在执行的线程，无论这个线程是在sleep，wait，还是正常运行

调用

结果

2.2利用停止标记

调用

结果

案例：JVM内存监控

线程安全单例

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用getInstance）时的线程安全，并思考注释中的问题

1.饿汉单例

2.枚举单例

3.懒汉单例

4. DCL懒汉单例

5.静态内部类懒汉单例

享元模式

1.简介

定义英文名称：Flyweight pattern.当需要重用数量有限的同一类对象时

出自"Gang of Four" design patterns

归类Structual patterns

2.体现

2.1包装类

在JDK中Boolean，Byte，Short，Integer，Long，Character等包装类提供了valueOf方法，例如Long的valueOf会缓存-128~127之间的Long对象，在这个范围之间会重用对象，大于这个范围，才会新建Long对象：

2.2 String串池

2.3 BigDecimal BigInteger

3. DIY
例如：一个线上商城应用，QPS达到数千，如果每次都重新创建和关闭数据库连接，性能会受到极大影响。这时预先创建好一批连接，放入连接池。一次请求到达后，从连接池获取连接，使用完毕后再还回连接池，这样既节约了连接的创建和关闭时间，也实现了连接的重用，不至于让庞大的连接数压垮数据库。

使用连接池：

以上实现没有考虑：

连接的动态增长与收缩

连接保活（可用性检测）

等待超时处理

分布式hash

对于关系型数据库，有比较成熟的连接池实现，例如c3p0, druid等对于更通用的对象池，可以考虑使用apachecommons pool，例如redis连接池可以参考jedis中关于连接池的实现

并发编程面试及答案

Synchronized相关问题

问题一：Synchronized用过吗，其原理是什么？

这是一道Java面试中几乎百分百会问到的问题，因为没有任何写过并发程序的开发者会没听说或者没接触过Synchronized。

Synchronized是由JVM实现的一种实现互斥同步的一种方式，如果你查看被Synchronized修饰过的程序块编译后的字节码，会发现，被Synchronized修饰过的程序块，在编译前后被编译器生成了monitorenter和monitorexit两个字节码指令。

这两个指令是什么意思呢？

在虚拟机执行到monitorenter指令时，首先要尝试获取对象的锁：如果这个对象没有锁定，或者当前线程已经拥有了这个对象的锁，把锁的计数器+1；当执行monitorexit指令时将锁计数器-1；当计数器为0时，锁就被释放了。

如果获取对象失败了，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。

Java中Synchronize通过在对象头设置标记，达到了获取锁和释放锁的目的。

问题二：你刚才提到获取对象的锁，这个“锁”到底是什么？如何确定对象的锁？
“锁”的本质其实是monitorenter和monitorexit字节码指令的一个Reference类型的参数，即要锁定和解锁的对象。我们知道，使用Synchronized可以修饰不同的对象，因此，对应的对象锁可以这么确定。
1.如果Synchronized明确指定了锁对象，比如Synchronized（变量名）、Synchronized(this)等，说明加解锁对象为该对象。

2.如果没有明确指定：若Synchronized修饰的方法为非静态方法，表示此方法对应的对象为锁对象；若Synchronized修饰的方法为静态方法，则表示此方法对应的类对象为锁对象。

注意，当一个对象被锁住时，对象里面所有用Synchronized修饰的方法都将产生堵塞，而对象里非Synchronized修饰的方法可正常被调用，不受锁影响。
问题三：什么是可重入性，为什么说Synchronized是可重入锁？
可重入性是锁的一个基本要求，是为了解决自己锁死自己的情况。比如下面的伪代码，一个类中的同步方法调用另一个同步方法，假如Synchronized不支持重入，进入method2方法时当前线程获得锁，method2方法里面执行method1时当前线程又要去尝试获取锁，这时如果不支持重入，它就要等释放，把自己阻塞，导致自己锁死自己。

对Synchronized来说，可重入性是显而易见的，刚才提到，在执行monitorenter指令时，如果这个对象没有锁定，或者当前线程已经拥有了这个对象的锁（而不是已拥有了锁则不能继续获取），就把锁的计数器+1，其实本质上就通过这种方式实现了可重入性。
问题四：JVM对Java的原生锁做了哪些优化？
在Java6之前，Monitor的实现完全依赖底层操作系统的互斥锁来实现，也就是我们刚才在问题二中所阐述的获取/释放锁的逻辑。由于Java层面的线程与操作系统的原生线程有映射关系，如果要将一个线程进行阻塞或唤起都需要操作系统的协助，这就需要从用户态切换到内核态来执行，这种切换代价十分昂贵，很耗处理器时间，现代JDK中做了大量的优化。

一种优化是使用自旋锁，即在把线程进行阻塞操作之前先让线程自旋等待一段时间，可能在等待期间其他线程已经解锁，这时就无需再让线程执行阻塞操作，避免了用户态到内核态的切换。现代JDK中还提供了三种不同的Monitor实现，也就是三种不同的锁：
1.偏向锁（BiasedLocking）

2.轻量级锁

3.重量级锁

这三种锁使得JDK得以优化Synchronized的运行，当JVM检测到不同的竞争状况时，会自动切换到适合的锁实现，这就是锁的升级、降级。

当没有竞争出现时，默认会使用偏向锁。

JVM会利用CAS操作，在对象头上的MarkWord部分设置线程ID，以表示这个对象偏向于当前线程，所以并不涉及真正的互斥锁，因为在很多应用场景中，大部分对象生命周期中最多会被一个线程锁定，使用偏斜锁可以降低无竞争开销。

如果有另一线程试图锁定某个被偏斜过的对象，JVM就撤销偏斜锁，切换到轻量级锁实现。

轻量级锁依赖CAS操作MarkWord来试图获取锁，如果重试成功，就使用普通的轻量级锁；否则，进一步升级为重量级锁。

问题五：为什么说Synchronized是非公平锁？

非公平主要表现在获取锁的行为上，并非是按照申请锁的时间前后给等待线程分配锁的，每当锁被释放后，任何一个线程都有机会竞争到锁，这样做的目的是为了提高执行性能，缺点是可能会产生线程饥饿现象。

问题六：什么是锁消除和锁粗化？
问题七：为什么说Synchronized是一个悲观锁？乐观锁的实现原理又是什么？什么是CAS，它有什么特性？

问题八：乐观锁一定就是好的吗？

可重入锁ReentrantLock及其他显式锁相关问题

问题一：跟Synchronized相比，可重入锁ReentrantLock其实现原理有什么不同？
问题二：那么请谈谈AQS框架是怎么回事儿？

问题三：请尽可能详尽地对比下Synchronized和ReentrantLock的异同。
问题四：ReentrantLock是如何实现可重入性的？
问题五：除了ReetrantLock，你还接触过JUC中的哪些并发工具？

问题六：请谈谈ReadWriteLock和StampedLock。
问题七：如何让Java的线程彼此同步？你了解过哪些同步器？请分别介绍下。
问题八：CyclicBarrier和CountDownLatch看起来很相似，请对比下呢？

Java线程池相关问题问

题一：Java中的线程池是如何实现的？

问题二：创建线程池的几个核心构造参数？
问题三：线程池中的线程是怎么创建的？是一开始就随着线程池的启动创建好的吗？

问题四：既然提到可以通过配置不同参数创建出不同的线程池，那么Java中默认实现好的线程池又有哪些呢？请比较它们的异同。

问题五：如何在Java线程池中提交线程？

Java内存模型相关问题

问题一：什么是Java的内存模型，Java中各个线程是怎么彼此看到对方的变量的？
问题二：请谈谈volatile有什么特点，为什么它能保证变量对所有线程的可见性？

问题三：既然volatile能够保证线程间的变量可见性，是不是就意味着基于volatile变量的运算就是并发安全的？

问题四：请对比下volatile对比Synchronized的异同。

问题五：请谈谈ThreadLocal是怎么解决并发安全的？

问题六：很多人都说要慎用ThreadLocal，谈谈你的理解，使用ThreadLocal需要注意些什么？

1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？

2)在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？

3)在java中wait和sleep方法的不同？

4）用Java实现阻塞队列。
5）用Java写代码来解决生产者——消费者问题。
6）用Java编程一个会导致死锁的程序，你将怎么解决？
7)什么是原子操作，Java中的原子操作是什么？
8)Java中的volatile关键是什么作用？怎样使用它？在Java中它跟synchronized方法有什么不同？
9)什么是竞争条件？你怎样发现和解决竞争？
10)你将如何使用threaddump？你将如何分析Threaddump？
11)为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？
12)Java中你怎样唤醒一个阻塞的线程？
13)在Java中CycliBarriar和CountdownLatch有什么区别？

14)什么是不可变对象，它对写并发应用有什么帮助？

15)你在多线程环境中遇到的常见的问题是什么？你是怎么解决它的？