Java中ThreadLocal有什么用

這篇文章將為大家詳細講解有關Java中ThreadLocal有什么用，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

一、ThreadLocal簡介

多線程訪問同一個共享變量的時候容易出現并發問題，特別是多個線程對一個變量進行寫入的時候，為了保證線程安全，一般使用者在訪問共享變量的時候需要進行額外的同步措施才能保證線程安全性。ThreadLocal是除了加鎖這種同步方式之外的一種保證一種規避多線程訪問出現線程不安全的方法，當我們在創建一個變量后，如果每個線程對其進行訪問的時候訪問的都是線程自己的變量這樣就不會存在線程不安全問題。

二、ThreadLocal簡單使用

下面的例子中，開啟兩個線程，在每個線程內部設置了本地變量的值，然后調用print方法打印當前本地變量的值。如果在打印之后調用本地變量的remove方法會刪除本地內存中的變量，代碼如下所示

package test;

public class ThreadLocalTest {

    static ThreadLocal<String> localVar = new ThreadLocal<>();

    static void print(String str) {
        //打印當前線程中本地內存中本地變量的值
        System.out.println(str + " :" + localVar.get());
        //清除本地內存中的本地變量
        localVar.remove();
    }

    public static void main(String[] args) {
        Thread t1  = new Thread(new Runnable() {
            @Override
            public void run() {
                //設置線程1中本地變量的值
                localVar.set("localVar1");
                //調用打印方法
                print("thread1");
                //打印本地變量
                System.out.println("after remove : " + localVar.get());
            }
        });

        Thread t2  = new Thread(new Runnable() {
            @Override
            public void run() {
                //設置線程1中本地變量的值
                localVar.set("localVar2");
                //調用打印方法
                print("thread2");
                //打印本地變量
                System.out.println("after remove : " + localVar.get());
            }
        });

        t1.start();
        t2.start();
    }
}

下面是運行后的結果：

三、ThreadLocal的實現原理

下面是ThreadLocal的類圖結構，從圖中可知：Thread類中有兩個變量threadLocals和inheritableThreadLocals，二者都是ThreadLocal內部類ThreadLocalMap類型的變量，我們通過查看內部內ThreadLocalMap可以發現實際上它類似于一個HashMap。

在默認情況下，每個線程中的這兩個變量都為null：

ThreadLocal.ThreadLocalMap threadLocals=null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals=null;

只有當線程第一次調用ThreadLocal的set或者get方法的時候才會創建他們（后面我們會查看這兩個方法的源碼）。除此之外，和我所想的不同的是，每個線程的本地變量不是存放在ThreadLocal實例中，而是放在調用線程的ThreadLocals變量里面（前面也說過，該變量是Thread類的變量）。也就是說，ThreadLocal類型的本地變量是存放在具體的線程空間上，其本身相當于一個裝載本地變量的工具殼，通過set方法將value添加到調用線程的threadLocals中，當調用線程調用get方法時候能夠從它的threadLocals中取出變量。如果調用線程一直不終止，那么這個本地變量將會一直存放在他的threadLocals中，所以不使用本地變量的時候需要調用remove方法將threadLocals中刪除不用的本地變量。下面我們通過查看ThreadLocal的set、get以及remove方法來查看ThreadLocal具體實怎樣工作的

1、set方法源碼

public void set(T value) {
    //(1)獲取當前線程（調用者線程）
    Thread t = Thread.currentThread();
    //(2)以當前線程作為key值，去查找對應的線程變量，找到對應的map
    ThreadLocalMap map = getMap(t);
    //(3)如果map不為null，就直接添加本地變量，key為當前定義的ThreadLocal變量的this引用，值為添加的本地變量值
    if (map != null)
        map.set(this, value);
    //(4)如果map為null，說明首次添加，需要首先創建出對應的map
    else
        createMap(t, value);
}

在上面的代碼中，(2)處調用getMap方法獲得當前線程對應的threadLocals(參照上面的圖示和文字說明)，該方法代碼如下

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals; //獲取線程自己的變量threadLocals，并綁定到當前調用線程的成員變量threadLocals上
}

如果調用getMap方法返回值不為null，就直接將value值設置到threadLocals中（key為當前線程引用，值為本地變量）；如果getMap方法返回null說明是第一次調用set方法（前面說到過，threadLocals默認值為null，只有調用set方法的時候才會創建map），這個時候就需要調用createMap方法創建threadLocals，該方法如下所示

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

createMap方法不僅創建了threadLocals，同時也將要添加的本地變量值添加到了threadLocals中。

2、get方法源碼

在get方法的實現中，首先獲取當前調用者線程，如果當前線程的threadLocals不為null，就直接返回當前線程綁定的本地變量值，否則執行setInitialValue方法初始化threadLocals變量。在setInitialValue方法中，類似于set方法的實現，都是判斷當前線程的threadLocals變量是否為null，是則添加本地變量（這個時候由于是初始化，所以添加的值為null），否則創建threadLocals變量，同樣添加的值為null。

public T get() {
    //(1)獲取當前線程
    Thread t = Thread.currentThread();
    //(2)獲取當前線程的threadLocals變量
    ThreadLocalMap map = getMap(t);
    //(3)如果threadLocals變量不為null，就可以在map中查找到本地變量的值
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //(4)執行到此處，threadLocals為null，調用該更改初始化當前線程的threadLocals變量
    return setInitialValue();
}

private T setInitialValue() {
    //protected T initialValue() {return null;}
    T value = initialValue();
    //獲取當前線程
    Thread t = Thread.currentThread();
    //以當前線程作為key值，去查找對應的線程變量，找到對應的map
    ThreadLocalMap map = getMap(t);
    //如果map不為null，就直接添加本地變量，key為當前線程，值為添加的本地變量值
    if (map != null)
        map.set(this, value);
    //如果map為null，說明首次添加，需要首先創建出對應的map
    else
        createMap(t, value);
    return value;
}

3、remove方法的實現

remove方法判斷該當前線程對應的threadLocals變量是否為null，不為null就直接刪除當前線程中指定的threadLocals變量

public void remove() {
    //獲取當前線程綁定的threadLocals
     ThreadLocalMap m = getMap(Thread.currentThread());
     //如果map不為null，就移除當前線程中指定ThreadLocal實例的本地變量
     if (m != null)
         m.remove(this);
}

如下圖所示：每個線程內部有一個名為threadLocals的成員變量，該變量的類型為ThreadLocal.ThreadLocalMap類型（類似于一個HashMap），其中的key為當前定義的ThreadLocal變量的this引用，value為我們使用set方法設置的值。每個線程的本地變量存放在自己的本地內存變量threadLocals中，如果當前線程一直不消亡，那么這些本地變量就會一直存在（所以可能會導致內存溢出），因此使用完畢需要將其remove掉。

四、ThreadLocal不支持繼承性

同一個ThreadLocal變量在父線程中被設置值后，在子線程中是獲取不到的。（threadLocals中為當前調用線程對應的本地變量，所以二者自然是不能共享的）

package test;

public class ThreadLocalTest2 {

    //(1)創建ThreadLocal變量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        //在main線程中添加main線程的本地變量
        threadLocal.set("mainVal");
        //新創建一個子線程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子線程中的本地變量值:"+threadLocal.get());
            }
        });
        thread.start();
        //輸出main線程中的本地變量值
        System.out.println("mainx線程中的本地變量值:"+threadLocal.get());
    }
}

五、InheritableThreadLocal類

在上面說到的ThreadLocal類是不能提供子線程訪問父線程的本地變量的，而InheritableThreadLocal類則可以做到這個功能，下面是該類的源碼

public class InheritableThreadLocal<T> extends ThreadLocal<T> {

    protected T childValue(T parentValue) {
        return parentValue;
    }

    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

從上面代碼可以看出，InheritableThreadLocal類繼承了ThreadLocal類，并重寫了childValue、getMap、createMap三個方法。其中createMap方法在被調用（當前線程調用set方法時得到的map為null的時候需要調用該方法）的時候，創建的是inheritableThreadLocal而不是threadLocals。同理，getMap方法在當前調用者線程調用get方法的時候返回的也不是threadLocals而是inheritableThreadLocal。

下面我們看看重寫的childValue方法在什么時候執行，怎樣讓子線程訪問父線程的本地變量值。我們首先從Thread類開始說起

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}
private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    //判斷名字的合法性
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }

    this.name = name;
    //(1)獲取當前線程(父線程)
    Thread parent = currentThread();
    //安全校驗
    SecurityManager security = System.getSecurityManager();
    if (g == null) { //g:當前線程組
        if (security != null) {
            g = security.getThreadGroup();
        }
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }
    g.checkAccess();
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }

    g.addUnstarted();

    this.group = g; //設置為當前線程組
    this.daemon = parent.isDaemon();//守護線程與否(同父線程)
    this.priority = parent.getPriority();//優先級同父線程
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    this.inheritedAccessControlContext =
            acc != null ? acc : AccessController.getContext();
    this.target = target;
    setPriority(priority);
    //(2)如果父線程的inheritableThreadLocal不為null
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        //（3）設置子線程中的inheritableThreadLocals為父線程的inheritableThreadLocals
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    this.stackSize = stackSize;

    tid = nextThreadID();
}

在init方法中，首先(1)處獲取了當前線程(父線程)，然后（2）處判斷當前父線程的inheritableThreadLocals是否為null，然后調用createInheritedMap將父線程的inheritableThreadLocals作為構造函數參數創建了一個新的ThreadLocalMap變量，然后賦值給子線程。下面是createInheritedMap方法和ThreadLocalMap的構造方法

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}

private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];

    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                //調用重寫的方法
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

在構造函數中將父線程的inheritableThreadLocals成員變量的值賦值到新的ThreadLocalMap對象中。返回之后賦值給子線程的inheritableThreadLocals。總之，InheritableThreadLocals類通過重寫getMap和createMap兩個方法將本地變量保存到了具體線程的inheritableThreadLocals變量中，當線程通過InheritableThreadLocals實例的set或者get方法設置變量的時候，就會創建當前線程的inheritableThreadLocals變量。而父線程創建子線程的時候，ThreadLocalMap中的構造函數會將父線程的inheritableThreadLocals中的變量復制一份到子線程的inheritableThreadLocals變量中。

六、從ThreadLocalMap看ThreadLocal使用不當的內存泄漏問題

1、基礎概念

首先我們先看看ThreadLocalMap的類圖，在前面的介紹中，我們知道ThreadLocal只是一個工具類，他為用戶提供get、set、remove接口操作實際存放本地變量的threadLocals（調用線程的成員變量），也知道threadLocals是一個ThreadLocalMap類型的變量，下面我們來看看ThreadLocalMap這個類。在此之前，我們回憶一下Java中的四種引用類型

①強引用：Java中默認的引用類型，一個對象如果具有強引用那么只要這種引用還存在就不會被GC。

②軟引用：簡言之，如果一個對象具有弱引用，在JVM發生OOM之前（即內存充足夠使用），是不會GC這個對象的；只有到JVM內存不足的時候才會GC掉這個對象。軟引用和一個引用隊列聯合使用，如果軟引用所引用的對象被回收之后，該引用就會加入到與之關聯的引用隊列中

③弱引用（這里討論ThreadLocalMap中的Entry類的重點）：如果一個對象只具有弱引用，那么這個對象就會被垃圾回收器GC掉(被弱引用所引用的對象只能生存到下一次GC之前，當發生GC時候，無論當前內存是否足夠，弱引用所引用的對象都會被回收掉)。弱引用也是和一個引用隊列聯合使用，如果弱引用的對象被垃圾回收期回收掉，JVM會將這個引用加入到與之關聯的引用隊列中。若引用的對象可以通過弱引用的get方法得到，當引用的對象唄回收掉之后，再調用get方法就會返回null

④虛引用：虛引用是所有引用中最弱的一種引用，其存在就是為了將關聯虛引用的對象在被GC掉之后收到一個通知。（不能通過get方法獲得其指向的對象）

2、分析ThreadLocalMap內部實現

上面我們知道ThreadLocalMap內部實際上是一個Entry數組

private Entry[] table;

我們先看看Entry的這個內部類

/**
 * 是繼承自WeakReference的一個類，該類中實際存放的key是
 * 指向ThreadLocal的弱引用和與之對應的value值(該value值
 * 就是通過ThreadLocal的set方法傳遞過來的值)
 * 由于是弱引用，當get方法返回null的時候意味著坑能引用
 */
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** value就是和ThreadLocal綁定的 */
    Object value;

    //k：ThreadLocal的引用，被傳遞給WeakReference的構造方法
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}
//WeakReference構造方法(public class WeakReference<T> extends Reference<T> )
public WeakReference(T referent) {
    super(referent); //referent：ThreadLocal的引用
}

//Reference構造方法
Reference(T referent) {
    this(referent, null);//referent：ThreadLocal的引用
}

Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

在上面的代碼中，我們可以看出，當前ThreadLocal的引用k被傳遞給WeakReference的構造函數，所以ThreadLocalMap中的key為ThreadLocal的弱引用。當一個線程調用ThreadLocal的set方法設置變量的時候，當前線程的ThreadLocalMap就會存放一個記錄，這個記錄的key值為ThreadLocal的弱引用，value就是通過set設置的值。如果當前線程一直存在且沒有調用該ThreadLocal的remove方法，如果這個時候別的地方還有對ThreadLocal的引用，那么當前線程中的ThreadLocalMap中會存在對ThreadLocal變量的引用和value對象的引用，是不會釋放的，就會造成內存泄漏。

考慮這個ThreadLocal變量沒有其他強依賴，如果當前線程還存在，由于線程的ThreadLocalMap里面的key是弱引用，所以當前線程的ThreadLocalMap里面的ThreadLocal變量的弱引用在gc的時候就被回收，但是對應的value還是存在的這就可能造成內存泄漏(因為這個時候ThreadLocalMap會存在key為null但是value不為null的entry項)。

關于“Java中ThreadLocal有什么用”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。