資訊專欄INFORMATION COLUMN
摘要：并發設計模式一模式的使用表示線程本地存儲模式。為不同的任務創建不同的線程池，這樣能夠有效的避免死鎖問題。兩階段終止，即將線程的結束分為了兩個階段，第一個階段是一個線程向另一個線程發送終止指令，第二個階段是線程響應終止指令。
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 類代碼如下：
