快捷導(dǎo)航

ThreadLocal工作原理及用法案例

更新時間：2021年12月25日 10:00:25 作者：卡斯特梅的雨傘

本文詳細講解了ThreadLocal工作原理及用法案例，文中通過示例代碼介紹的非常詳細。對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下

ThreadLocal是什么

ThreadLocal是線程Thread中屬性threadLocals即ThreadLocal.ThreadLocalMap的管理者，ThreadLocal用于給每個線程操作自己線程的本地變量，通過線程私有從而保證線程安全性。

ThreadLocal原理

拿get()方法來說，線程的本地變量是存放在線程實例的屬性ThreadLocalMap上的，ThreadLocalMap本質(zhì)上就是一個HashMap，ThreadLocal只是一個管理者，當(dāng)我們的線程需要拿到自己的本地變量時，我們直接調(diào)用ThreadLocal去get本地變量即可。
因為get()方法底層會先獲取到當(dāng)前線程，然后通過當(dāng)前線程拿到他的屬性值ThreadLocalMap，如果ThreadLocalMap為空，則會調(diào)用ThreadLocal的初始化方法拿到初始值返回，如果不為空，則會拿該ThreadLocal作為key去獲取該線程下的ThreadLocalMap里對應(yīng)的value值。

ThreadLocal內(nèi)存泄漏問題

線程的屬性值ThreadLocalMap中使用的 key 為 ThreadLocal 的弱引用,而value是強引用。所以，如果ThreadLocal沒有被外部強引用的情況下，在垃圾回收的時候，key 會被清理掉，而value 不會被清理掉。這樣的話，ThreadLocalMap 中就會出現(xiàn) key 為 null 的 Entry。假如我們不做任何措施的話，value 永遠無法被 GC 回收，這個時候就可能會產(chǎn)生內(nèi)存泄露。
因此針對這種情況，我們有兩種原則：

ThreadLocal申明為private static final。JDK建議ThreadLocal定義為private static，這樣ThreadLocal的弱引用問題則不存在了。
- private與final 盡可能不讓他人修改變更引用。
- static 表示為類屬性，只有在程序結(jié)束才會被回收。
ThreadLocal使用后務(wù)必調(diào)用remove方法。
- 最簡單有效的方法是使用后將其移除。

關(guān)于InheritableThreadLocal

InheritableThreadLocal類是ThreadLocal類的子類。ThreadLocal中每個線程擁有它自己的值，與ThreadLocal不同的是，InheritableThreadLocal允許一個線程以及該線程創(chuàng)建的所有子線程都可以訪問它保存的值。

代碼示例

ThreadLocal使用

public class ThreadLocalTest {

    //第一種初始化方式
    /**
     * 聲明為static是讓ThreadLocal實例隨著程序的結(jié)束才結(jié)束，這樣才不會讓GC回收了
     * 聲明為final是讓ThreadLocal實例引用不會被替換，這樣子也不會因為被替換導(dǎo)致被GC回收
     * 這兩個聲明都是為了避免作為key的ThreadLocal對象沒有外部強引用而導(dǎo)致被GC回收，從而導(dǎo)致內(nèi)存泄漏的問題，因為ThreadLocalMap<ThreadLocal, Object>中的ThreadLocal
     * 對象作為key是弱引用，會被GC回收。
     */
    private static final ThreadLocal<String> threadLocalStr = ThreadLocal.withInitial(() -> "fresh");

    private static AtomicInteger intGen = new AtomicInteger(0);
    //第二種初始化方式
    private static final ThreadLocal<Integer> threadLocalInt = new ThreadLocal<Integer>() {
        @Override
        public Integer initialValue() {
            return intGen.incrementAndGet();
        }
    };

    public static void main(String[] args) throws InterruptedException {
        ArrayList<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            Thread t = new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalInt.get());
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalStr.get());
                    TimeUnit.SECONDS.sleep(5);
                    threadLocalStr.set("bojack horseman" + threadLocalInt.get());
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalInt.get());
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalStr.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    threadLocalInt.remove();
                    threadLocalStr.remove();
                }
            });
            t.start();
            threads.add(t);
        }
        TimeUnit.SECONDS.sleep(2);
        System.out.println(threads);
        System.out.println(threadLocalStr);
        System.out.println(threadLocalInt);
    }
    /**
     * Thread-0   1
     * Thread-1   2
     * Thread-0   fresh
     * Thread-1   fresh
     * [Thread[Thread-0,5,main], Thread[Thread-1,5,main]]
     * java.lang.ThreadLocal$SuppliedThreadLocal@1ef7fe8e
     * cn.vv.schedule.test.ThreadLocalTest$1@6f79caec
     * Thread-1   2
     * Thread-1   bojack horseman2
     * Thread-0   1
     * Thread-0   bojack horseman1
     */

}

InheritableThreadLocal使用

public class InheritableThreadLocalTest {

    //第一種初始化方式
    private static final InheritableThreadLocal<String> threadLocalStr = new InheritableThreadLocal<String>() {
        @Override
        public String initialValue() {
            return "fresh";
        }
    };
    private static AtomicInteger intGen = new AtomicInteger(0);
    //第二種初始化方式
    private static final ThreadLocal<Integer> threadLocalInt = new ThreadLocal<Integer>() {
        @Override
        public Integer initialValue() {
            return intGen.incrementAndGet();
        }
    };

    public static void main(String[] args) throws InterruptedException {
        //如果是InheritableThreadLocal，則父線程創(chuàng)建的所有子線程都會復(fù)制一份父線程的線程變量，而不是去初始化一份線程變量
        threadLocalStr.set("main");
        ArrayList<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            Thread t = new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalInt.get());
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalStr.get());
                    TimeUnit.SECONDS.sleep(5);
                    //子線程可以自由地改變自己的本地變量
                    threadLocalStr.set("bojack horseman" + threadLocalInt.get());
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalInt.get());
                    System.out.println(Thread.currentThread().getName() + "   " + threadLocalStr.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    threadLocalInt.remove();
                    threadLocalStr.remove();
                }
            });
            t.start();
            threads.add(t);
        }
        TimeUnit.SECONDS.sleep(2);
        System.out.println(Thread.currentThread().getName() + "   " + threadLocalStr.get());
    }
    /**
     * Thread-0   2
     * Thread-1   1
     * Thread-0   main
     * Thread-1   main
     * main   main
     * Thread-0   2
     * Thread-0   bojack horseman2
     * Thread-1   1
     * Thread-1   bojack horseman1
     */

}