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的好處：

傳遞資料：保存每個執行緒系結的資料，在需要的地方可以直接獲取, 避免參數直接傳遞帶來的代碼耦合問題
執行緒隔離：各執行緒之間的資料相互隔離卻又具備并發性，避免同步方式帶來的性能損失

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 = https://www.cnblogs.com/wzp123456/p/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也是獨立實作，

成員變數

/**
     * 初始容量 —— 必須是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;
    }

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

    Entry(ThreadLocal k, Object v) {
        super(k);
        value = https://www.cnblogs.com/wzp123456/p/v;
    }
}
```
在ThreadLocalMap中，也是用Entry來保存K-V結構資料的，但是Entry中key只能是ThreadLocal物件，這點被Entry的構造方法已經限定死了；
另外，Entry繼承WeakReference,使用弱參考，可以將ThreadLocal物件的生命周期和執行緒生命周期解綁，持有對ThreadLocal的弱參考，可以使得ThreadLocal在沒有其他強參考的時候被回收掉，這樣可以避免因為執行緒得不到銷毀導致ThreadLocal物件無法被回收

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 = https://www.cnblogs.com/wzp123456/p/value;
            return;
        }
        /**
             * table[i]上的key為空，說明被回收了
             * 這個時候table[i]可以重新使用，用新的key-value將其替換,并洗掉其他無效的entry
             */
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/225462.html

標籤：Java

上一篇：網路編程之初識 Tomcat

下一篇：機器人大冒險

ThreadLocal應用及原始碼分析