ThreadLocal工作原理及用法是什么

今天就跟大家聊聊有關ThreadLocal工作原理及用法是什么，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。

ThreadLocal是什么

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

ThreadLocal原理

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

ThreadLocal內存泄漏問題

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

• ThreadLocal申明為private static final。JDK建議ThreadLocal定義為private static，這樣ThreadLocal的弱引用問題則不存在了。

• private與final 盡可能不讓他人修改變更引用。

• static 表示為類屬性，只有在程序結束才會被回收。

• ThreadLocal使用后務必調用remove方法。

• 最簡單有效的方法是使用后將其移除。

關于InheritableThreadLocal

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

代碼示例

ThreadLocal使用

public class ThreadLocalTest {

    //第一種初始化方式
    /**
     * 聲明為static是讓ThreadLocal實例隨著程序的結束才結束，這樣才不會讓GC回收了
     * 聲明為final是讓ThreadLocal實例引用不會被替換，這樣子也不會因為被替換導致被GC回收
     * 這兩個聲明都是為了避免作為key的ThreadLocal對象沒有外部強引用而導致被GC回收，從而導致內存泄漏的問題，因為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，則父線程創建的所有子線程都會復制一份父線程的線程變量，而不是去初始化一份線程變量
        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
     */

}

看完上述內容，你們對ThreadLocal工作原理及用法是什么有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。