ThreadLocal應用及原始碼分析

西涼馬戳戳發表於2020-11-20
thread原始碼
ThreadLocal

基本使用

ThreadLocal 的作用是：提供執行緒內的區域性變數，不同的執行緒之間不會相互干擾，這種變數線上程的生命週期內起作用，減少同一個執行緒內多個函式或元件之間一些公共變數傳遞的複雜度，降低耦合性。

方法宣告 描述
ThreadLocal() 建立ThreadLocal物件
public void set( T value) 設定當前執行緒繫結的區域性變數
public T get() 獲取當前執行緒繫結的區域性變數
public void remove() 移除當前執行緒繫結的區域性變數

簡單使用：

public class MyDemo {
    private String content;

    private String getContent() {
        return content;
    }

    private void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        MyDemo demo = new MyDemo();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.setContent(Thread.currentThread().getName() + "的資料");
                    System.out.println("-----------------------");
             		System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
                }
            });
            thread.setName("執行緒" + i);
            thread.start();
        }
    }
}


public class MyDemo {

    private static ThreadLocal<String> tl = new ThreadLocal<>();

    private String content;

    private String getContent() {
        return tl.get();
    }

    private void setContent(String content) {
         tl.set(content);
    }

    public static void main(String[] args) {
        MyDemo demo = new MyDemo();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.setContent(Thread.currentThread().getName() + "的資料");
                    System.out.println("-----------------------");
                    System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
                }
            });
            thread.setName("執行緒" + i);
            thread.start();
        }
    }
}

這樣可以很好的解決多執行緒之間資料隔離的問題，用synchronized加鎖也可以實現，但synchronized側重的是多個執行緒之間訪問資源的同步性，而ThreadLocal側重的是每個執行緒之間的資料隔離。

synchronized ThreadLocal
原理 同步機制採用'以時間換空間'的方式, 只提供了一份變數,讓不同的執行緒排隊訪問 ThreadLocal採用'以空間換時間'的方式, 為每一個執行緒都提供了一份變數的副本,從而實現同時訪問而相不干擾
側重點 多個執行緒之間訪問資源的同步性 多執行緒中讓每個執行緒之間的資料相互隔離

應用場景

涉及到資料傳遞和執行緒隔離的場景，可以考慮用ThreadLocal來解決：轉賬案例，涉及兩個DML操作： 一個轉出，一個轉入。這些操作是需要具備原子性的。所以這裡就需要操作事務，來保證轉出和轉入操作具備原子性。開啟事務的注意兩點：

  • 為了保證所有的操作在一個事務中, 使用的連線必須是同一個: service層開啟事務的connection需要跟dao層訪問資料庫的connection保持一致。
  • 執行緒併發情況下, 每個執行緒只能操作各自的 connection。

用ThreadLocal的解決方案：在獲取Connection連線的JdbcUtils工具類加入ThreadLocal，程式碼如下：

public class JdbcUtils {
    //ThreadLocal物件 : 將connection繫結在當前執行緒中
    private static final ThreadLocal<Connection> tl = new ThreadLocal();

    // c3p0 資料庫連線池物件屬性
    private static final ComboPooledDataSource ds = new ComboPooledDataSource();

    // 獲取連線
    public static Connection getConnection() throws SQLException {
        //取出當前執行緒繫結的connection物件
        Connection conn = tl.get();
        if (conn == null) {
            //如果沒有，則從連線池中取出
            conn = ds.getConnection();
            //再將connection物件繫結到當前執行緒中
            tl.set(conn);
        }
        return conn;
    }

    //釋放資源
    public static void release(AutoCloseable... ios) {
        for (AutoCloseable io : ios) {
            if (io != null) {
                try {
                    io.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void commitAndClose() {
        try {
            Connection conn = getConnection();
            //提交事務
            conn.commit();
            //解除繫結
            tl.remove();
            //釋放連線
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void rollbackAndClose() {
        try {
            Connection conn = getConnection();
            //回滾事務
            conn.rollback();
            //解除繫結
            tl.remove();
            //釋放連線
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

可以看出使用ThreadLocal的好處：

  1. 傳遞資料 ： 儲存每個執行緒繫結的資料，在需要的地方可以直接獲取, 避免引數直接傳遞帶來的程式碼耦合問題
  2. 執行緒隔離 ： 各執行緒之間的資料相互隔離卻又具備併發性，避免同步方式帶來的效能損失

ThreadLocal的內部結構

jdk8以前：

jdk8之前使用ThreadLocal來維護一個ThreadLocalMap，以執行緒作為key

jdk8以後：

jdk8之後使用Thread來維護一個ThreadLocalMap，以ThreadLocal作為key

這樣涉及的好處：

（1） 每個Map儲存的Entry數量就會變少，因為jdk8之前的儲存數量由Thread的數量決定，現在是由ThreadLocal的數量決定。

（2） 當Thread銷燬之後，對應的ThreadLocalMap也會隨之銷燬，能減少記憶體的使用。

ThreadLocal核心方法的原始碼

方法宣告 描述
protected T initialValue() 返回當前執行緒區域性變數的初始值
public void set( T value) 設定當前執行緒繫結的區域性變數
public T get() 獲取當前執行緒繫結的區域性變數
public void remove() 移除當前執行緒繫結的區域性變數

get()

/**
     * 返回當前執行緒中儲存ThreadLocal的值
     * 如果當前執行緒沒有此ThreadLocal變數，
     * 則它會通過呼叫{@link #initialValue} 方法進行初始化值
     *
     * @return 返回當前執行緒對應此ThreadLocal的值
     */
public T get() {
    // 獲取當前執行緒物件
    Thread t = Thread.currentThread();
    // 獲取此執行緒物件中維護的ThreadLocalMap物件
    ThreadLocalMap map = getMap(t);
    // 如果此map存在
    if (map != null) {
        // 以當前的ThreadLocal 為 key，呼叫getEntry獲取對應的儲存實體e
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 找到對應的儲存實體 e 
        if (e != null) {
            @SuppressWarnings("unchecked")
            // 獲取儲存實體 e 對應的 value值
            // 即為我們想要的當前執行緒對應此ThreadLocal的值
            T result = (T)e.value;
            return result;
        }
    }
    // 如果map不存在，則證明此執行緒沒有維護的ThreadLocalMap物件
    // 呼叫setInitialValue進行初始化
    return setInitialValue();
}

/**
     * set的變樣實現，用於初始化值initialValue，
     * 用於代替防止使用者重寫set()方法
     *
     * @return the initial value 初始化後的值
     */
private T setInitialValue() {
    // 呼叫initialValue獲取初始化的值
    T value = initialValue();
    // 獲取當前執行緒物件
    Thread t = Thread.currentThread();
    // 獲取此執行緒物件中維護的ThreadLocalMap物件
    ThreadLocalMap map = getMap(t);
    // 如果此map存在
    if (map != null)
        // 存在則呼叫map.set設定此實體entry
        map.set(this, value);
    else
        // 1）當前執行緒Thread 不存在ThreadLocalMap物件
        // 2）則呼叫createMap進行ThreadLocalMap物件的初始化
        // 3）並將此實體entry作為第一個值存放至ThreadLocalMap中
        createMap(t, value);
    // 返回設定的值value
    return value;
}

/**
     * 獲取當前執行緒Thread對應維護的ThreadLocalMap 
     * 
     * @param  t the current thread 當前執行緒
     * @return the map 對應維護的ThreadLocalMap 
     */
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
/**
     *建立當前執行緒Thread對應維護的ThreadLocalMap 
     *
     * @param t 當前執行緒
     * @param firstValue 存放到map中第一個entry的值
     */
void createMap(Thread t, T firstValue) {
    //這裡的this是呼叫此方法的threadLocal
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

首先呼叫Thread.currentThread()方法獲取當前執行緒物件，然後根據當前執行緒獲取維護的ThreadLocalMap物件；如果獲取的Map不為空，則在Map中以ThreadLocal的引用作為key，呼叫getEntry獲取對應的儲存實體，如果Entry不為空，獲取對應的 value值。如果Map為空或者Entry為空，則呼叫setInitialValue()方法。setInitialValue()方法裡，呼叫initialValue()方法獲取初始化值value，然後判斷當前執行緒是否有ThreadLocalMap，map存在，呼叫set設定Entry；map不存在則呼叫createMap()進行ThreadLocalMap物件的初始化，並將此entry作為第一個值存放至ThreadLocalMap中。

set()

/**
     * 設定當前執行緒對應的ThreadLocal的值
     *
     * @param value 將要儲存在當前執行緒對應的ThreadLocal的值
     */
public void set(T value) {
    // 獲取當前執行緒物件
    Thread t = Thread.currentThread();
    // 獲取此執行緒物件中維護的ThreadLocalMap物件
    ThreadLocalMap map = getMap(t);
    // 如果此map存在
    if (map != null)
        // 存在則呼叫map.set設定此實體entry
        map.set(this, value);
    else
        // 1）當前執行緒Thread 不存在ThreadLocalMap物件
        // 2）則呼叫createMap進行ThreadLocalMap物件的初始化
        // 3）並將此實體entry作為第一個值存放至ThreadLocalMap中
        createMap(t, value);
}

​ A. 首先獲取當前執行緒，並根據當前執行緒獲取一個ThreadLocalMap

​ B. 如果獲取的Map不為空，則將引數設定到Map中（當前ThreadLocal的引用作為key）

​ C. 如果Map為空，則呼叫createMap給該執行緒建立 Map，並設定初始值

remove()

/**
     * 刪除當前執行緒中儲存的ThreadLocal對應的實體entry
     */
public void remove() {
    // 獲取當前執行緒物件中維護的ThreadLocalMap物件
    ThreadLocalMap m = getMap(Thread.currentThread());
    // 如果此map存在
    if (m != null)
        // 存在則呼叫map.remove
        // 以當前ThreadLocal為key刪除對應的實體entry
        m.remove(this);
}

A. 首先獲取當前執行緒，並根據當前執行緒獲取一個ThreadLocalMap

B. 如果獲取的Map不為空，則移除當前ThreadLocal物件對應的entry

initialValue()

protected T initialValue() {
    return null;
}

（1） 這個方法是一個延遲呼叫方法，在set方法還未呼叫而先呼叫了get方法時才執行，並且僅執行1次。

（2）這個方法直接返回一個null。

（3）如果想要一個除null之外的初始值，可以重寫此方法。（備註： 該方法是一個protected的方法，顯然是為了讓子類覆蓋而設計的）

ThreadLocalMap

ThreadLocalMap是ThreadLocal的內部類，沒有實現Map介面，用獨立的方式實現了Map的功能，其內部的Entry也是獨立實現。

  1. 成員變數

    /**
     * 初始容量 —— 必須是2的整次冪
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * 存放資料的table
     * 同樣，陣列長度必須是2的冪。
     */
    private Entry[] table;

    /**
     * 陣列裡面entrys的個數，可以用於判斷table當前使用量是否超過負載因子。
     */
    private int size = 0;

    /**
     * 進行擴容的閾值，表使用量大於它的時候進行擴容。
     */
    private int threshold; // Default to 0
    
    /**
     * 閾值設定為長度的2/3
     */
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }

  2. Entry

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

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

    在ThreadLocalMap中，也是用Entry來儲存K-V結構資料的。但是Entry中key只能是ThreadLocal物件，這點被Entry的構造方法已經限定死了；
    另外，Entry繼承WeakReference,使用弱引用，可以將ThreadLocal物件的生命週期和執行緒生命週期解綁，持有對ThreadLocal的弱引用，可以使得ThreadLocal在沒有其他強引用的時候被回收掉，這樣可以避免因為執行緒得不到銷燬導致ThreadLocal物件無法被回收

  3. hash衝突的解決

    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化table
    table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY]; //16
    //計算索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //設定值
    table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
    size = 1;
    //設定閾值
    setThreshold(INITIAL_CAPACITY);
}

    • & (INITIAL_CAPACITY - 1),這是取模的一種方式，對於2的冪取模，用此代替%(2^n)，這也就是為啥容量必須為2的冪

    • firstKey.threadLocalHashCode：

      private final int threadLocalHashCode = nextHashCode();
    
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
private static AtomicInteger nextHashCode =  new AtomicInteger();

private static final int HASH_INCREMENT = 0x61c88647;

      這裡定義了一個AtomicInteger型別，每次獲取當前值並加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,這個值是32位整型上限2^32-1乘以黃金分割比例0.618....的值2654435769，用有符號整型表示就是-1640531527，去掉符號後16進製表示為0x61c88647，目的就是為了讓雜湊碼能均勻的分佈在2的n次方的陣列Entry[] table中。

    • 線性探測法：

      該方法一次探測下一個地址，直到有空的地址後插入，若整個空間都找不到空餘的地址，則產生溢位。假設當前table長度為16，也就是說如果計算出來key的hash值為14，如果table[14]上已經有值，並且其key與當前key不一致，那麼就發生了hash衝突，這個時候將14加1得到15，取table[15]進行判斷，這個時候如果還是衝突會回到0，取table[0],以此類推，直到可以插入。可以把table看成一個環形陣列

       /**
     * 獲取環形陣列的下一個索引
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

    /**
     * 獲取環形陣列的上一個索引
     */
    private static int prevIndex(int i, int len) {
        return ((i - 1 >= 0) ? i - 1 : len - 1);
    }

    • ThreadLocalMap的set()：

      private void set(ThreadLocal<?> key, Object value) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    //計算索引
    int i = key.threadLocalHashCode & (len-1);
    /**
         * 根據獲取到的索引進行迴圈，如果當前索引上的table[i]不為空，在沒有return的情況下，
         * 就使用nextIndex()獲取下一個（線性探測法）。
         */
    for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        //table[i]上key不為空，並且和當前key相同，更新value
        if (k == key) {
            e.value = value;
            return;
        }
        /**
             * table[i]上的key為空，說明被回收了
             * 這個時候table[i]可以重新使用，用新的key-value將其替換,並刪除其他無效的entry
             */
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

相關文章