目录
Single Thread Execution 设计模式
机场过安检
Single Thread Execution 模式是指在同一时刻只能有一个线程去访问共享资源，就 像独木桥一样每次只允许一人通行，简单来说， Single Thread Execution 就是采用排 他式的操作保证在同一时刻只能有一个线程访问共享资源。 相信大家都有乘坐飞机的经历，在进入登机口之前必须经过安全检査，安检口类似于独木桥，每次只能通过一个人，工作人员除了检査你的登机牌以外，还要联网检查身份证信息以及是否携带危险物品，如下图所示。
非线程安全
先模拟一个非线程安全的安检口类，旅客（线程）分别手持登机牌和身份证接受工作人 员的检查，示例代码如下所示。
package com.tong.chapter14;
public class FlightSecurity {
private int count = 0;
private String boardingPass = "null";// 登机牌
private String idCard = "null";// 身份证
public void pass(String boardingPass, String idCard) {
this.boardingPass = boardingPass;
this.idCard = idCard;
this.count++;
check();
}
private void check() {
// 简单的业务，当登机牌和身份证首位不相同时则表示检查不通过
if (boardingPass.charAt(0) != idCard.charAt(0)) {
throw new RuntimeException("-----Exception-----" + toString());
}
}
@Override
public String toString() {
return "FlightSecurity{" + "count=" + count + ", boardingPass='" + boardingPass + '\'' + ", idCard='" + idCard + '\'' + '}';
}
}FlightSecurity 比较简单，提供了一个 pass 方法，将旅客的登机牌和身份证传递给 pass 方法，在 pass 方法中调用 check 方法对旅客进行检查，检查的逻辑也足够的简单， 只需要检测登机牌和身份证首位是否相等（当然这样在现实中非常不合理，但是为了使测试简单我们约定这么做），我们看以下代码所示的测试。
package com.tong.chapter14;
public class FlightSecurityTest {
static class Passengers extends Thread {
// 机场安检类
private final FlightSecurity flightSecurity;
// 旅客身份证
private final String idCard;
// 旅客登机牌
private final String boardingPass;
public Passengers(FlightSecurity flightSecurity, String idCard, String boardingPass) {
this.flightSecurity = flightSecurity;
this.idCard = idCard;
this.boardingPass = boardingPass;
}
@Override
public void run() {
while (true) {
// 旅客不断地过安检
flightSecurity.pass(boardingPass, idCard);
}
}
}
public static void main(String[] args) {
// 定义三个旅客，身份证和登机牌首位均相同
final FlightSecurity flightsecurity = new FlightSecurity();
new Passengers(flightsecurity, "Al23456", "AF123456").start();
new Passengers(flightsecurity, "B123456", "BF123456").start();
new Passengers(flightsecurity, "C123456", "CF123456").start();
}
}看起来每一个客户都是合法的，因为每一个客户的身份证和登机牌首字母都一样，运行 上面的程序却出现了错误，而且错误的情况还不太一样，运行多次，发现了两种类型的错误信息，程序输出如下：
java.lang.RuntimeException: -----Exception-----FlightSecurity{count=218,boardingPass='AF123456', idCard='B123456'}
java.lang.RuntimeException: -----Exception-----FlightSecurity{count=676,boardingPass='BF123456', 首字母相同检查不能通过和首字母不相同检查不能通过，为什么会出现这样的情况呢？ 首字母相同却不能通过？更加奇怪的是传入的参数明明全都是首字母相同的，为什么会出现首字母不相同的错误呢。
问题分析
首字母相同却未通过检查
1)线程 A 调用 pass 方法，传人”A123456”“AF123456”并且对 idcard 赋值成功，由 于 CPU 调度器时间片的轮转，CPU 的执行权归 B 线程所有。
2) 线程 B 调用 pass 方法，传入”B123456”“BF123456”并且对 idcard 赋值成功， 覆盖 A 线程赋值的 idCard。
3)线程 A 重新获得 CPU 的执行权，将 boardingPass 赋于 AF123456,因此 check 无 法通过。
4)在输出 toString 之前，B 线程成功将 boardingPass 覆盖为 BF123456。
为何出现首字母不相同的情况
1)线程 A 调用 pass 方法，传入”A123456”“AF123456”并且对 id Card 赋值成功，由 于 CPU 调度器时间片的轮转，CPU 的执行权归 B 线程所有。
2)线程 B 调用 pass 方法，传入”B123456”“BF123456”并且对 id Card 赋值成功，覆 盖 A 线程赋值的 idCard。
3)线程 A 重新获得 CPU 的执行权，将 boardingPass 赋于 AF123456,因此 check 无 法通过。
4)线程 A 检查不通过，输出 idcard=”A123456”和 boardingPass=”BF123456”。
线程安全
上面出现的问题说到底就是数据同步的问题，虽然线程传递给 pass 方法的两个参数能 够百分之百地保证首字母相同，可是在为 FlightSecurity 中的属性赋值的时候会出现多个线程交错的情况，结合我们之前所讲内容可知，需要对共享资源增加同步保护，改进代码如下。
public synchronized void pass(String boardingPass, String idCard) {
this.boardingPass = boardingPass;
this.idCard = idCard;
this.count++;
check();
}修改后的 pass 方法，无论运行多久都不会再出现检查出错的情况了，为什么只在 pas 方法增加 synchronized 关键字， check 以及 toString 方法都有对共享资源的访问，难道它们不加同步就不会引起错误么？由于 check 方法是在 pass 方法中执行的，pass 方法加同步已经保证了 single thread execution，因此 check 方法不需要增加同步， toString 方法原因与此相同。
何时适合使用 single thread execution 模式呢？答案如下。
A. 多线程访问资源的时候，被 synchronized 同步的方法总是排他性的。
B. 多个线程对某个类的状态发生改变的时候，比如 Flightsecurity 的登机牌以及身 份证。
在 Java 中经常会听到线程安全的类和线程非安全的类，所谓线程安全的类是指多个线 程在对某个类的实例同时进行操作时，不会引起数据不一致的问题，反之则是线程非安全的类，在线程安全的类中经常会看到 synchronized 关键字的身影
Future 设计模式
Future 模式有点类似于商品订单。比如在网购时，当看重某一件商品事，就可以提交 订单，当订单处理完成后，在家里等待商品送货上门即可。或者说更形象的我们发送 Ajax 请求的时候，页面是异步的进行后台处理，用户无须一直等待请求的结果，可以继续浏览或 操作其他内容。
Master-Worker 设计模式
Master- Worker 模式是常用的并行计算模式。它的核心思想是系统由两类进程协作工 作： Master 进程和 Worker 进程。 Master 负责接收和分配任务，Worker 负责处理子任 务。当各个 Worker-子进程处理完成后，会将结果返回给 Master，由 Master 做归纳和总 结。其好处是能将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量。
具体代码实现逻辑图如下：
生产者消费者设计模式
生产者和消费者也是一个非常经典的多线程模式，我们在实际开发中应用非常广泛的思 想理念。在生产消费模式中：通常由两类线程，即若干个生产者的线程和若干个消费者的线程。生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务，在生产者和消费者之间通过共享内存缓存区进行通信。
具体代码逻辑实现思路：
Immutable 不可变对象设计模式
不可变对象一定是线程安全的。
关于时间日期 API 线程不安全的问题
想必大家对 SimpleDateFormat 并不陌生。SimpleDateFormat 是 Java 中一个非常 常用的类，该类用来对日期字符串进行解析和格式化输出，但如果使用不小心会导致非常微 妙和难以调试的问题，因为 DateFormat 和 SimpleDateFormat 类不都是线程安全的， 在多线程环境下调用 format() 和 parse() 方法应该使用同步代码来避免问题。关于时间日期 API 的线程不安全问题直到 JDK8 出现以后才得到解决。
关于线程不安全的代码示例如下：
package com.tong.chapter18.demo01;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;
public class SimpleDateFormatThreadUnsafe {
public static void main(String[] args) throws ExecutionException,
InterruptedException {
// 初始化时间日期 API
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
// 创建任务线程，执行任务将字符串转成指定格式日期
Callable<Date> task = () -> sdf.parse("20200808");
// 创建线程池，数量为 10
ExecutorService pool = Executors.newFixedThreadPool(10);
// 构建结果集
List<Future<Date>> results = new ArrayList<>();
// 开始执行任务线程，将结果添加至结果集
for (int i = 0; i < 10; i++) {
results.add(pool.submit(task));
}
// 打印结果集中的内容
// 在任务线程执行过程中并且访问结果集内容就会报错
for (Future<Date> future : results) {
System.out.println(future.get());
}
// 关闭线程池
pool.shutdown();
}
}运行结果如下：
我们先自己来解决一下这个问题，线程不安全，我给它放到 ThreadLocal 中是否可行呢？
package com.tong.chapter18.demo01;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 将每次需要格式转换的参数都放入 ThreadLocal 中进行
*/
public class DateFormatThreadLocal {
private static final ThreadLocal<DateFormat> df = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));
public static Date convert(String source) throws ParseException {
return df.get().parse(source);
}
}然后格式化日期代码如下：
package com.tong.chapter18.demo01;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;
public class SimpleDateFormatThreadSafe {
public static void main(String[] args) throws ExecutionException,InterruptedException {
// 初始化时间日期 API
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
// 创建任务线程，执行任务将字符串转成指定格式日期
//Callable<Date> task = () -> sdf.parse("20191020");
// 使用 ThreadLocal 处理非线程安全
Callable<Date> task = () -> DateFormatThreadLocal.convert("20191020");
// 创建线程池，数量为 10
ExecutorService pool = Executors.newFixedThreadPool(10);
// 构建结果集
List<Future<Date>> results = new ArrayList<>();
// 开始执行任务线程，将结果添加至结果集
for (int i = 0; i < 10; i++) {
results.add(pool.submit(task));
}
// 打印结果集中的内容
// 在任务线程执行过程中并且访问结果集内容就会报错
for (Future<Date> future : results) {
System.out.println(future.get());
}
// 关闭线程池
pool.shutdown();
}
}上面的程序不管运行多少次都不会再出现线程不安全的问题。
定义不可变对象的策略
如何定义不可变对象呢？官方文档描述如下：
参考官网文档后设计一个不可变对象，如下：
package com.tong.chapter18.demo02;
public final class Person {
private final String name;
private final String address;
public Person(final String name, final String address) {
this.name = name;
this.address = address;
}
public String getName() {
return name;
}
public String getAddress()
return address;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", address='" + address + '\'' + '}';
}
}
