概述

最近在對一個專案進行重構，用到了ThreadLocal。場景如下：外圍系統會呼叫介面上傳資料，在介面中要記錄資料的變化Id，在上傳資料完後需要集中在一個地方把這些Id以訊息形式傳送出去。

使用場景樣例程式碼

    public Result<Void> uploadOrder(TotalPayInfoVo totalPayInfoVo) {
        try {
            saveTotalPayInfoVo(totalPayInfoVo);

            //傳送訊息
            UnitWork.getCurrent().pushMessage();
        } catch
 
 (Exception e) {
            cashLogger.error("uploadOrder error，data: {}， error: {}", JSON.toJSONString(totalPayInfoVo), e);
            throw new RuntimeException("儲存失敗", e);
        } finally {
            UnitWork.clean();//
        }

        return ResultUtil.successResult();避免記憶體洩漏
    }

ThreadLocal使用原始碼

/**
 * 工作單元，在同一個執行緒中負責記錄一個事件或者一個方法或者一個事務過程中產生的變化，等操作結束後再處理這種變化。
 */
public class UnitWork {
    private UnitWork() {
    }

    private static ThreadLocal<UnitWork> current = new ThreadLocal<UnitWork>() {
        protected UnitWork initialValue() {
            return new UnitWork();
        }
    };

    /**
     * 狀態變化的instance
     */
 

    private Set<String> statusChangedInstances = new HashSet<>();

    public void addStatusChangedInstance(String instance) {
        statusChangedInstances.add(instance);
    }

    /**
     * 推送訊息
     */
    public void pushMessage() {

       for(String id : statusChangedInstances){
            //非同步發訊息
       }
    }

    public static UnitWork getCurrent() {
        return current.get();
    }

    /**
     * 刪除當前執行緒的工作單元，建議放在finally中呼叫，避免記憶體洩漏
     */
    public static void clean() {
        current.remove();
    }

}

思考問題

為了避免記憶體洩漏，每次用完做一下clean清理操作。傳送訊息的過程是非同步的，意味著clean的時候可能和傳送訊息同時進行。那麼會不會把這些Id清理掉？那麼可能造成訊息傳送少了。要回答這個問題，首先要搞懂ThreadLocal的引用關係，remove操作做了什麼？

ThreadLocal解讀

ThreadLocal可以分別在各個執行緒儲存變數獨立副本。每個執行緒都有ThreadLocalMap，顧名思義，類似Map容器，不過是用陣列Entry[]來模擬的。那麼既然類似Map，肯定會存在Key。其實Key是ThreadLocal型別，Key的值是ThreadLocal的HashCode，即通過threadLocalHashCode計算出來的值。
這個Map的Entry並不是ThreadLocal，而是一個帶有弱引用的Entry。既然是弱引用，每次GC的時候都會回收。

        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

而Key對應的value就是要儲存線上程副本Object，這裡指的就是UnitWork的例項。呼叫ThreadLocal的get方法時，首先找到當前執行緒的ThreadLocalMap，然後根據這個ThreadLocal算出來的hashCode找到儲存執行緒副本Object。他們的關係對應如下：

ThreadLocal在remove的時候，會呼叫Entry的clear，即弱引用的clear方法。把Key->ThreadLocal的引用去掉。接下來的expungeStaleEntry會把entry中value引用設定為null。

        /**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

現在可以回答之前提前的問題。雖然ThreadLocal和當前執行緒都會與Object脫離了引用的關係，但是最重要一點就是非同步的執行緒仍然存在一條強引用路徑到Object，即到UnitWork例項的強引用。因此GC然後不會回收UnitWork的例項，發訊息還是不會少發或者出現空指標情況。