摘要：并发设计模式一模式的使用表示线程本地存储模式。为不同的任务创建不同的线程池，这样能够有效的避免死锁问题。两阶段终止，即将线程的结束分为了两个阶段，第一个阶段是一个线程向另一个线程发送终止指令，第二个阶段是线程响应终止指令。
Java 并发设计模式 一、Thread Local Storage 模式 1. ThreadLocal 的使用
Thread Local Storage 表示线程本地存储模式。
大多数并发问题都是由于变量的共享导致的，多个线程同时读写同一变量便会出现原子性，可见性等问题。局部变量是线程安全的，本质上也是由于各个线程各自拥有自己的变量，避免了变量的共享。
Java 中使用了 ThreadLocal 来实现避免变量共享的方案。ThreadLocal 保证在线程访问变量时，会创建一个这个变量的副本，这样每个线程都有自己的变量值，没有共享，从而避免了线程不安全的问题。
下面是 ThreadLocal 的一个简单使用示例：
public class ThreadLocalTest {
private static final ThreadLocal threadLocal =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
public static SimpleDateFormat safeDateFormat() {
return threadLocal.get();
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask task1 = new FutureTask<>(ThreadLocalTest::safeDateFormat);
FutureTask task2 = new FutureTask<>(ThreadLocalTest::safeDateFormat);
Thread t1 = new Thread(task1);
Thread t2 = new Thread(task2);
t1.start();
t2.start();
System.out.println(task1.get() == task2.get());//返回false，表示两个对象不相等
}
}
程序中构造了一个线程安全的 SimpleDateFormat ，两个线程取到的是不同的示例对象，这样就保证了线程安全。
2. ThreadLocal 原理浅析线程 Thread 类内部有两个 ThreadLocalMap 类型的变量：
/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; /* * InheritableThreadLocal values pertaining to this thread. This map is * maintained by the InheritableThreadLocal class. */ ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
其中第二个变量的用途是创建可继承父线程变量的子线程，只不过这并不常用，主要介绍第一个。
ThreadLocalMap 是一个用于存储 ThreadLocal 的特殊 HashMap，map 中 key 就是 ThreadLocal，value 是线程变量值。只不过这个 map 并不被 ThreadLocal 持有，而是被 Thread 持有。
当调用 ThreadLocal 类中的 set 方法时，就会创建 Thread 中的 threadLocals 属性。
//ThreadLocal的set方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);//获取Thread中的ThreadLocalMap
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
可以看到，最终的 ThreadLocal 对象和变量值并不是创建在 ThreadLocal 内部，而是 Thread 中的 ThreadLocalMap，ThreadLocal 在这里只是充当了代理的作用。
3. ThreadLocal 内存泄漏问题存储数据的 TheadLocalMap 被 Thread 持有，而不是 ThreadLocal，主要的原因便是 ThreadLocal 的生命周期比 Thread 要长，如果 ThreadLocal 对象一直存在，那么 map 中的线程就不能被回收，容易导致内存泄漏。
而 Thread 持有 ThreadLocalMap，并且 ThreadLocalMap 对 ThreadLocal 的引用还是弱引用，这样当线程被回收时，map 也能够被回收，更加安全。
但是 Java 的这种设计并没有完全避免内存泄漏问题。如果线程池中的线程存活时间过长，那么其持有的 ThreadLocalMap 一直不会被释放。ThreadLocalMap 中的 Entry 对其 value 是强引用的（对 ThreadLocal 是弱引用），这样就算 ThreadLocalMap 的生命周期结束了，但是 value 值并没有被回收。
解决的办法便是手动释放 ThreadLocalMap 中对 value 的强引用，可以使用 TheadLocal 的 remove 方法。在 finally 语句块中执行。例如下面这个简单的示例：
public class ThreadLocalTest {
private final ThreadLocal threadLocal = new ThreadLocal<>();
public void test(){
//设置变量值
threadLocal.set(10);
try {
System.out.println(threadLocal.get());
}
finally {
//释放
threadLocal.remove();
}
}
}
二、Immutability 模式
1. 不可变的概念
Immutability，即不变模式。可以理解为只要对象一经创建，其状态是不能够被改变的，无法进行写操作。
要实现 Immuatability 模式很简单，将一个类本身及其所有的属性都设为 final ，并且方法都是只读的，需要注意的是，如果类的属性也是引用类型，那么其对应的类也要满足不可变的特性。final 应该都很熟悉了，用它来修饰类和方法，分别表示类不可继承、属性不可改变。
Java 中具备不可变性的类型包括：
String
final 修饰的基本数据类型
Integer、Long、Double 等基本数据类型的包装类
Collections 中的不可变集合
具备不可变性的类，如果需要有类似修改这样的功能，那么它不会像普通的对象一样改变自己的属性，而是创建新的对象。
下面是 String 的字符串连接方法 concat() 的源码，仔细观察，可以看到最后方法返回的时候，创建了一个新的 Sring 对象：
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
//创建新的对象
return new String(buf, true);
}
而 Collections 工具可以将集合变为不可变的，完全禁止写、修改等操作。示例如下：
//Collections 中构建不可变集合的方法 Collections.unmodifiableList(); Collections.unmodifiableSet(); Collections.unmodifiableMap(); Collections.unmodifiableSortedSet(); Collections.unmodifiableSortedMap(); --- List2. 对象池list = Arrays.asList(1, 2, 3, 4, 5); //构建不可变集合 List unmodifiableList = Collections.unmodifiableList(list); unmodifiableList.remove(1);//抛出异常
对于一个不可变性的类，如果频繁的对其进行修改操作，那么一直会创建性新的对象，这样就比较浪费内存空间了，一种解决办法便是利用对象池。
原理也很简单，新建对象的时候，去对象池看是否存在对象，如果存在则直接利用，如果不存在才会创建新的对象，创建之后再将对象放到对象池中。
以长整型的包装类 Long 为例，它缓存了 -128 到 127 的数据，如果创建的是这个区间的对象，那么会直接使用缓存中的对象。例如 Long 中的 valueOf 方法就用到了这个缓存，然后直接返回：
public static Long valueOf(long l) {
final int offset = 128;
//在这个区间则直接使用缓存中的对象
if (l >= -128 && l <= 127) { // will cache
return LongCache.cache[(int)l + offset];
}
return new Long(l);
}
三、Guarded Suspension 模式
1. Guarded Suspension 实现
Guarded Suspension 意为保护性暂停。一个典型的使用场景是：当客户端线程 T 发送请求后，服务端这时有大量的请求需要处理，这时候就需要排队，线程 T 进入等待状态，直到服务端处理完请求并且返回结果。
Guarded Suspension 的实现很简单，有一个对象 GuardedObject，其内部有一个属性，即被保护的对象，还有两个方法，客户端调用 get() 方法，如果未获取到结果，则进入等待状态，即“保护性暂停”；还有一个 notice() 通知方法，当服务端处理完请求后，调用这个方法，并且唤醒等待中的线程。示意图如下：
示例代码如下：
public class GuardedObject{ private T obj; private final Lock lock = new ReentrantLock(); private final Condition finished = lock.newCondition(); //调用方线程获取结果 T get(){ lock.lock(); try { while (未获取到结果){ finished.await(); } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } return obj; } //执行完后通知 void notice(T obj){ lock.lock(); try { this.obj = obj; finished.signalAll(); } finally { lock.unlock(); } } }
从代码中可以看到，Guarded Suspension 模式本质上就是一种等待-通知机制，只不过使用这种模式，在解决实际的问题的时候，需要根据情况进行程序功能的扩展。
2. 使用示例还是上面提到的那个例子，当客户端发送请求后，需要等待服务端的响应结果，这时候就可以使用 Guarded Suspension 来实现，下面是代码示例：
public class SendRequest{ //相当于消息队列 private final BlockingQueue queue = new ArrayBlockingQueue<>(5); //客户端发送请求 void send(Request request) throws InterruptedException { //将消息存放至队列中 queue.put(request); //创建Guarded Suspension模式的对象 GuardedObject guardedObject = GuardedObject.create(request.id); //循环等待，获取结果 Request res = guardedObject.get(Objects::nonNull); } //服务端处理请求 void handle() throws InterruptedException { //从队列中获取请求 Request request = queue.take(); //调用请求对应的GuardedObject，并处理请求 GuardedObject.handleRequest(request.id, request); } //请求类 private static class Request{ private int id; private String content; } }
需要注意的是，这里并不是直接使用 new GuardedObject() 的方式来创建对象，这是因为需要找到每个请求和对象之间的对应关系，所以 GuardedObject 内部使用了一个 map 来保存对象，key 是对应的请求 id。
GuardedObject 类代码如下：
