Java ThreadLocal的使用場景總結
我們以多線程格式化時間為例，來演示 ThreadLocal 的價值和作用，當我們在多個線程中格式化時間時，通常會這樣操作。
① 2個線程格式化當有 2 個線程進行時間格式化時，我們可以這樣寫：
import java.text.SimpleDateFormat;import java.util.Date;public class Test { public static void main(String[] args) throws InterruptedException {// 創建并啟動線程1Thread t1 = new Thread(new Runnable() { @Override public void run() {// 得到時間對象Date date = new Date(1 * 1000);// 執行時間格式化formatAndPrint(date); }});t1.start();// 創建并啟動線程2Thread t2 = new Thread(new Runnable() { @Override public void run() {// 得到時間對象Date date = new Date(2 * 1000);// 執行時間格式化formatAndPrint(date); }});t2.start(); } /** * 格式化并打印結果 * @param date 時間對象 */ private static void formatAndPrint(Date date) {// 格式化時間對象SimpleDateFormat simpleDateFormat = new SimpleDateFormat('mm:ss');// 執行格式化String result = simpleDateFormat.format(date);// 打印最終結果System.out.println('時間：' + result); }}
以上程序的執行結果為：
上面的代碼因為創建的線程數量并不多，所以我們可以給每個線程創建一個私有對象 SimpleDateFormat 來進行時間格式化。
② 10個線程格式化當線程的數量從 2 個升級為 10 個時，我們可以使用 for 循環來創建多個線程執行時間格式化，具體實現代碼如下：
import java.text.SimpleDateFormat;import java.util.Date;public class Test { public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 10; i++) { int finalI = i; // 創建線程 Thread thread = new Thread(new Runnable() {@Overridepublic void run() { // 得到時間對象 Date date = new Date(finalI * 1000); // 執行時間格式化 formatAndPrint(date);} }); // 啟動線程 thread.start();} } /** * 格式化并打印時間 * @param date 時間對象 */ private static void formatAndPrint(Date date) {// 格式化時間對象SimpleDateFormat simpleDateFormat = new SimpleDateFormat('mm:ss');// 執行格式化String result = simpleDateFormat.format(date);// 打印最終結果System.out.println('時間：' + result); }}
以上程序的執行結果為：
從上述結果可以看出，雖然此時創建的線程數和 SimpleDateFormat 的數量不算少，但程序還是可以正常運行的。
③ 1000個線程格式化然而當我們將線程的數量從 10 個變成 1000 個的時候，我們就不能單純的使用 for 循環來創建 1000 個線程的方式來解決問題了，因為這樣頻繁的新建和銷毀線程會造成大量的系統開銷和線程過度爭搶 CPU 資源的問題。
所以經過一番思考后，我們決定使用線程池來執行這 1000 次的任務，因為線程池可以復用線程資源，無需頻繁的新建和銷毀線程，也可以通過控制線程池中線程的數量來避免過多線程所導致的 **CPU** 資源過度爭搶和線程頻繁切換所造成的性能問題，而且我們可以將 SimpleDateFormat 提升為全局變量，從而避免每次執行都要新建 SimpleDateFormat 的問題，于是我們寫下了這樣的代碼：
import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class App { // 時間格式化對象 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat('mm:ss'); public static void main(String[] args) throws InterruptedException {// 創建線程池執行任務ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60,TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));for (int i = 0; i < 1000; i++) { int finalI = i; // 執行任務 threadPool.execute(new Runnable() {@Overridepublic void run() { // 得到時間對象 Date date = new Date(finalI * 1000); // 執行時間格式化 formatAndPrint(date);} });}// 線程池執行完任務之后關閉threadPool.shutdown(); } /** * 格式化并打印時間 * @param date 時間對象 */ private static void formatAndPrint(Date date) {// 執行格式化String result = simpleDateFormat.format(date);// 打印最終結果System.out.println('時間：' + result); }}
以上程序的執行結果為：
當我們懷著無比喜悅的心情去運行程序的時候，卻發現意外發生了，這樣寫代碼竟然會出現線程安全的問題。從上述結果可以看出，程序的打印結果竟然有重復內容的，正確的情況應該是沒有重復的時間才對。
PS：所謂的線程安全問題是指：在多線程的執行中，程序的執行結果與預期結果不相符的情況。
a) 線程安全問題分析為了找到問題所在，我們嘗試查看 SimpleDateFormat 中 format 方法的源碼來排查一下問題，format 源碼如下：
private StringBuffer format(Date date, StringBuffer toAppendTo,FieldDelegate delegate) { // 注意此行代碼 calendar.setTime(date); boolean useDateFormatSymbols = useDateFormatSymbols(); for (int i = 0; i < compiledPattern.length; ) {int tag = compiledPattern[i] >>> 8;int count = compiledPattern[i++] & 0xff;if (count == 255) { count = compiledPattern[i++] << 16; count |= compiledPattern[i++];}switch (tag) { case TAG_QUOTE_ASCII_CHAR:toAppendTo.append((char)count);break; case TAG_QUOTE_CHARS:toAppendTo.append(compiledPattern, i, count);i += count;break; default:subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);break;} } return toAppendTo;}
從上述源碼可以看出，在執行 SimpleDateFormat.format 方法時，會使用 calendar.setTime 方法將輸入的時間進行轉換，那么我們想象一下這樣的場景：
線程 1 執行了 calendar.setTime(date) 方法，將用戶輸入的時間轉換成了后面格式化時所需要的時間； 線程 1 暫停執行，線程 2 得到 CPU 時間片開始執行； 線程 2 執行了 calendar.setTime(date) 方法，對時間進行了修改； 線程 2 暫停執行，線程 1 得出 CPU 時間片繼續執行，因為線程 1 和線程 2 使用的是同一對象，而時間已經被線程 2 修改了，所以此時當線程 1 繼續執行的時候就會出現線程安全的問題了。正常的情況下，程序的執行是這樣的：
非線程安全的執行流程是這樣的：
當出現線程安全問題時，我們想到的第一解決方案就是加鎖，具體的實現代碼如下：
import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class App { // 時間格式化對象 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat('mm:ss'); public static void main(String[] args) throws InterruptedException {// 創建線程池執行任務ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60,TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));for (int i = 0; i < 1000; i++) { int finalI = i; // 執行任務 threadPool.execute(new Runnable() {@Overridepublic void run() { // 得到時間對象 Date date = new Date(finalI * 1000); // 執行時間格式化 formatAndPrint(date);} });}// 線程池執行完任務之后關閉threadPool.shutdown(); } /** * 格式化并打印時間 * @param date 時間對象 */ private static void formatAndPrint(Date date) {// 執行格式化String result = null;// 加鎖synchronized (App.class) { result = simpleDateFormat.format(date);}// 打印最終結果System.out.println('時間：' + result); }}
以上程序的執行結果為：
從上述結果可以看出，使用了 synchronized 加鎖之后程序就可以正常的執行了。
加鎖的缺點
加鎖的方式雖然可以解決線程安全的問題，但同時也帶來了新的問題，當程序加鎖之后，所有的線程必須排隊執行某些業務才行，這樣無形中就降低了程序的運行效率了。
有沒有既能解決線程安全問題，又能提高程序的執行速度的解決方案呢？
答案是：有的，這個時候 ThreadLocal 就要上場了。
c) 解決線程安全問題：ThreadLocal1.ThreadLocal 介紹ThreadLocal 從字面的意思來理解是線程本地變量的意思，也就是說它是線程中的私有變量，每個線程只能使用自己的變量。
以上面線程池格式化時間為例，當線程池中有 10 個線程時，SimpleDateFormat 會存入 ThreadLocal 中，它也只會創建 10 個對象，即使要執行 1000 次時間格式化任務，依然只會新建 10 個 SimpleDateFormat 對象，每個線程調用自己的 ThreadLocal 變量。
2.ThreadLocal 基礎使用ThreadLocal 常用的核心方法有三個：
set 方法：用于設置線程獨立變量副本。 沒有 set 操作的 ThreadLocal 容易引起臟數據。 get 方法：用于獲取線程獨立變量副本。 沒有 get 操作的 ThreadLocal 對象沒有意義。 remove 方法：用于移除線程獨立變量副本。 沒有 remove 操作容易引起內存泄漏。ThreadLocal 所有方法如下圖所示：
官方說明文檔：https://docs.oracle.com/javase/8/docs/api/
ThreadLocal 基礎用法如下：
/** * @公眾號：Java中文社群 */public class ThreadLocalExample { // 創建一個 ThreadLocal 對象 private static ThreadLocal<String> threadLocal = new ThreadLocal<>(); public static void main(String[] args) {// 線程執行任務Runnable runnable = new Runnable() { @Override public void run() {String threadName = Thread.currentThread().getName();System.out.println(threadName + ' 存入值：' + threadName);// 在 ThreadLocal 中設置值threadLocal.set(threadName);// 執行方法，打印線程中設置的值print(threadName); }};// 創建并啟動線程 1new Thread(runnable, 'MyThread-1').start();// 創建并啟動線程 2new Thread(runnable, 'MyThread-2').start(); } /** * 打印線程中的 ThreadLocal 值 * @param threadName 線程名稱 */ private static void print(String threadName) {try { // 得到 ThreadLocal 中的值 String result = threadLocal.get(); // 打印結果 System.out.println(threadName + ' 取出值：' + result);} finally { // 移除 ThreadLocal 中的值（防止內存溢出） threadLocal.remove();} }}
以上程序的執行結果為：
從上述結果可以看出，每個線程只會讀取到屬于自己的 ThreadLocal 值。
3.ThreadLocal 高級用法① 初始化：initialValue
public class ThreadLocalByInitExample { // 定義 ThreadLocal private static ThreadLocal<String> threadLocal = new ThreadLocal(){@Overrideprotected String initialValue() { System.out.println('執行 initialValue() 方法'); return '默認值';} }; public static void main(String[] args) {// 線程執行任務Runnable runnable = new Runnable() { @Override public void run() {// 執行方法，打印線程中數據（未設置值打印）print(threadName); }};// 創建并啟動線程 1new Thread(runnable, 'MyThread-1').start();// 創建并啟動線程 2new Thread(runnable, 'MyThread-2').start(); } /** * 打印線程中的 ThreadLocal 值 * @param threadName 線程名稱 */ private static void print(String threadName) {// 得到 ThreadLocal 中的值String result = threadLocal.get();// 打印結果System.out.println(threadName + ' 得到值：' + result); }}
以上程序的執行結果為：
當使用了 #threadLocal.set 方法之后，initialValue 方法就不會被執行了，如下代碼所示：
public class ThreadLocalByInitExample { // 定義 ThreadLocal private static ThreadLocal<String> threadLocal = new ThreadLocal() {@Overrideprotected String initialValue() { System.out.println('執行 initialValue() 方法'); return '默認值';} }; public static void main(String[] args) {// 線程執行任務Runnable runnable = new Runnable() { @Override public void run() {String threadName = Thread.currentThread().getName();System.out.println(threadName + ' 存入值：' + threadName);// 在 ThreadLocal 中設置值threadLocal.set(threadName);// 執行方法，打印線程中設置的值print(threadName); }};// 創建并啟動線程 1new Thread(runnable, 'MyThread-1').start();// 創建并啟動線程 2new Thread(runnable, 'MyThread-2').start(); } /** * 打印線程中的 ThreadLocal 值 * @param threadName 線程名稱 */ private static void print(String threadName) {try { // 得到 ThreadLocal 中的值 String result = threadLocal.get(); // 打印結果 System.out.println(threadName + '取出值：' + result);} finally { // 移除 ThreadLocal 中的值（防止內存溢出） threadLocal.remove();} }}
以上程序的執行結果為：
為什么 set 方法之后，初始化代碼就不執行了？要理解這個問題，需要從 ThreadLocal.get() 方法的源碼中得到答案，因為初始化方法 initialValue 在 ThreadLocal 創建時并不會立即執行，而是在調用了 get 方法只會才會執行，測試代碼如下：
import java.util.Date;public class ThreadLocalByInitExample { // 定義 ThreadLocal private static ThreadLocal<String> threadLocal = new ThreadLocal() {@Overrideprotected String initialValue() { System.out.println('執行 initialValue() 方法 ' + new Date()); return '默認值';} }; public static void main(String[] args) {// 線程執行任務Runnable runnable = new Runnable() { @Override public void run() {// 得到當前線程名稱String threadName = Thread.currentThread().getName();// 執行方法，打印線程中設置的值print(threadName); }};// 創建并啟動線程 1new Thread(runnable, 'MyThread-1').start();// 創建并啟動線程 2new Thread(runnable, 'MyThread-2').start(); } /** * 打印線程中的 ThreadLocal 值 * @param threadName 線程名稱 */ private static void print(String threadName) {System.out.println('進入 print() 方法 ' + new Date());try { // 休眠 1s Thread.sleep(1000);} catch (InterruptedException e) { e.printStackTrace();}// 得到 ThreadLocal 中的值String result = threadLocal.get();// 打印結果System.out.println(String.format('%s 取得值：%s %s',threadName, result, new Date())); }}
以上程序的執行結果為：
從上述打印的時間可以看出：initialValue 方法并不是在 ThreadLocal 創建時執行的，而是在調用 Thread.get 方法時才執行的。
接下來來看 Threadlocal.get 源碼的實現：
public T get() { // 得到當前的線程 Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); // 判斷 ThreadLocal 中是否有數據 if (map != null) {ThreadLocalMap.Entry e = map.getEntry(this);if (e != null) { @SuppressWarnings('unchecked') T result = (T)e.value; // 有 set 值，直接返回數據 return result;} } // 執行初始化方法【重點關注】 return setInitialValue();}private T setInitialValue() { // 執行初始化方法【重點關注】 T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null)map.set(this, value); elsecreateMap(t, value); return value;}
從上述源碼可以看出，當 ThreadLocal 中有值時會直接返回值 e.value，只有 Threadlocal 中沒有任何值時才會執行初始化方法 initialValue。
注意事項—類型必須保持一致注意在使用 initialValue 時，返回值的類型要和 ThreadLoca 定義的數據類型保持一致，如下圖所示：
如果數據不一致就會造成 ClassCaseException 類型轉換異常，如下圖所示：
② 初始化2：withInitial
import java.util.function.Supplier;public class ThreadLocalByInitExample { // 定義 ThreadLocal private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(new Supplier<String>() {@Overridepublic String get() { System.out.println('執行 withInitial() 方法'); return '默認值';} }); public static void main(String[] args) {// 線程執行任務Runnable runnable = new Runnable() { @Override public void run() {String threadName = Thread.currentThread().getName();// 執行方法，打印線程中設置的值print(threadName); }};// 創建并啟動線程 1new Thread(runnable, 'MyThread-1').start();// 創建并啟動線程 2new Thread(runnable, 'MyThread-2').start(); } /** * 打印線程中的 ThreadLocal 值 * @param threadName 線程名稱 */ private static void print(String threadName) {// 得到 ThreadLocal 中的值String result = threadLocal.get();// 打印結果System.out.println(threadName + ' 得到值：' + result); }}
通過上述的代碼發現，withInitial 方法的使用好和 initialValue 好像沒啥區別，那為啥還要造出兩個類似的方法呢？客官莫著急，繼續往下看。
③ 更簡潔的 withInitial 使用withInitial 方法的優勢在于可以更簡單的實現變量初始化，如下代碼所示：
public class ThreadLocalByInitExample { // 定義 ThreadLocal private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> '默認值'); public static void main(String[] args) {// 線程執行任務Runnable runnable = new Runnable() { @Override public void run() {String threadName = Thread.currentThread().getName();// 執行方法，打印線程中設置的值print(threadName); }};// 創建并啟動線程 1new Thread(runnable, 'MyThread-1').start();// 創建并啟動線程 2new Thread(runnable, 'MyThread-2').start(); } /** * 打印線程中的 ThreadLocal 值 * @param threadName 線程名稱 */ private static void print(String threadName) {// 得到 ThreadLocal 中的值String result = threadLocal.get();// 打印結果System.out.println(threadName + ' 得到值：' + result); }}
以上程序的執行結果為：
了解了 ThreadLocal 的使用之后，我們回到本文的主題，接下來我們將使用 ThreadLocal 來實現 1000 個時間的格式化，具體實現代碼如下：
import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class MyThreadLocalByDateFormat { // 創建 ThreadLocal 并設置默認值 private static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat('mm:ss')); public static void main(String[] args) {// 創建線程池執行任務ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60,TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));// 執行任務for (int i = 0; i < 1000; i++) { int finalI = i; // 執行任務 threadPool.execute(new Runnable() {@Overridepublic void run() { // 得到時間對象 Date date = new Date(finalI * 1000); // 執行時間格式化 formatAndPrint(date);} });}// 線程池執行完任務之后關閉threadPool.shutdown();// 線程池執行完任務之后關閉threadPool.shutdown(); } /** * 格式化并打印時間 * @param date 時間對象 */ private static void formatAndPrint(Date date) {// 執行格式化String result = dateFormatThreadLocal.get().format(date);// 打印最終結果System.out.println('時間：' + result); }}
以上程序的執行結果為：
從上述結果可以看出，使用 ThreadLocal 也可以解決線程并發問題，并且避免了代碼加鎖排隊執行的問題。
使用場景2：跨類傳遞數據除了上面的使用場景之外，我們還可以使用 **ThreadLocal** 來實現線程中跨類、跨方法的數據傳遞。比如登錄用戶的 User 對象信息，我們需要在不同的子系統中多次使用，如果使用傳統的方式，我們需要使用方法傳參和返回值的方式來傳遞 User 對象，然而這樣就無形中造成了類和類之間，甚至是系統和系統之間的相互耦合了，所以此時我們可以使用 ThreadLocal 來實現 User 對象的傳遞。
確定了方案之后，接下來我們來實現具體的業務代碼。我們可以先在主線程中構造并初始化一個 User 對象，并將此 User 對象存儲在 ThreadLocal 中，存儲完成之后，我們就可以在同一個線程的其他類中，如倉儲類或訂單類中直接獲取并使用 User 對象了，具體實現代碼如下。
主線程中的業務代碼：
public class ThreadLocalByUser { public static void main(String[] args) {// 初始化用戶信息User user = new User('Java');// 將 User 對象存儲在 ThreadLocal 中UserStorage.setUser(user);// 調用訂單系統OrderSystem orderSystem = new OrderSystem();// 添加訂單（方法內獲取用戶信息）orderSystem.add();// 調用倉儲系統RepertorySystem repertory = new RepertorySystem();// 減庫存（方法內獲取用戶信息）repertory.decrement(); }}
User 實體類：
/** * 用戶實體類 */class User { public User(String name) {this.name = name; } private String name; public String getName() {return name; } public void setName(String name) {this.name = name; }}
ThreadLocal 操作類：
/** * 用戶信息存儲類 */class UserStorage { // 用戶信息 public static ThreadLocal<User> USER = new ThreadLocal(); /** * 存儲用戶信息 * @param user 用戶數據 */ public static void setUser(User user) {USER.set(user); }}
訂單類：
/** * 訂單類 */class OrderSystem { /** * 訂單添加方法 */ public void add() {// 得到用戶信息User user = UserStorage.USER.get();// 業務處理代碼（忽略）...System.out.println(String.format('訂單系統收到用戶：%s 的請求。',user.getName())); }}
倉儲類：
/** * 倉儲類 */class RepertorySystem { /** * 減庫存方法 */ public void decrement() {// 得到用戶信息User user = UserStorage.USER.get();// 業務處理代碼（忽略）...System.out.println(String.format('倉儲系統收到用戶：%s 的請求。',user.getName())); }}
以上程序的最終執行結果：
從上述結果可以看出，當我們在主線程中先初始化了 User 對象之后，訂單類和倉儲類無需進行任何的參數傳遞也可以正常獲得 User 對象了，從而實現了一個線程中，跨類和跨方法的數據傳遞。
總結使用 ThreadLocal 可以創建線程私有變量，所以不會導致線程安全問題，同時使用 ThreadLocal 還可以避免因為引入鎖而造成線程排隊執行所帶來的性能消耗；再者使用 ThreadLocal 還可以實現一個線程內跨類、跨方法的數據傳遞。
以上就是Java ThreadLocal的使用場景總結的詳細內容，更多關于Java ThreadLocal的使用場景的資料請關注好吧啦網其它相關文章！
相關文章：
網公網安備