ThreadLocal

概念：

• ThreadLocal提供了线程本地变量，也就是如果创建一个ThreadLocal变量，那么访问的这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存的里面的变量，从而避免了线程安全问题。
• 每个Thread维护一个ThreadLocalMap，key为使用弱引用的ThreadLocal实例，value为线程变量的副本。
• 扩容：使用开放寻址方法；

package com.example.demo;

/**
 * @author SHshuo
 * @data 2021/11/6--14:17
 * ThreadLocal提供了线程本地变量，也就是如果创建一个ThreadLocal变量，
 * 那么访问的这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，
 * 实际操作的是自己本地内存的里面的变量，从而避免了线程安全问题。
 *
 * 不具有继承性
 */
public class ThreadLocalTest {

//    创建ThreadLocal变量
    static ThreadLocal<String> localVariable = new ThreadLocal<>();

    public static void main(String[] args) {
//        创建两个线程、使用ThreadLocal
        new Thread(() -> {
            localVariable.set("Thread Of A local variable");
            System.out.println("Thread Of A  : " + localVariable.get());

//            移除本地内存保存的副本
            localVariable.remove();

//            获取的是本地内存保存的副本、而不是主内存
            System.out.println("Thread Of A remove : " + localVariable.get());
        }, "A").start();

        new Thread(() -> {
            localVariable.set("Thread Of B local variable");
            System.out.println("Thread Of B  : " + localVariable.get());

//            移除本地内存保存的副本
            localVariable.remove();
            System.out.println("Thread Of B remove : " + localVariable.get());
        }, "B").start();
    }

}

实现原理，简单来说：

• 每个线程的本地变量不是存放在ThreadLocal的实例里面，而是存放在调用线程的threadLocals变量（也就是每一个线程的本地内存的变量）里面。
• ThreadLocal类型的本地变量存放在具体的线程内存空间中。ThreadLocal就是一个工具壳。
• threadLocals是一个hashmap的结构，其中key就是当前ThreadLocal的实例对象引用，value是通过set方法传递的值。

解决线程之间的值传递

ThreadLocal不具有继承性

package com.example.demo;

/**
 * @author SHshuo
 * @data 2021/11/6--14:33
 */
public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        threadLocal.set("With inheritance");

        new Thread(() -> System.out.println("子线程: " + threadLocal.get())).start();

        System.out.println("main: " + threadLocal.get());
    }
}

父子线程进行值传递

package com.example.demo;

/**
 * @author SHshuo
 * @data 2021/11/6--14:33
 * 通过将本地变量复制一份到子线程变量里实现继承。获取仍然是本地内存的变量
 * inheritance继承性的意思、使用InheritableThreadLocal实现
 */
public class InheritableThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();
        inheritableThreadLocal.set("With inheritance");

        new Thread(() -> System.out.println("子线程: " + inheritableThreadLocal.get())).start();

        System.out.println("main: " + inheritableThreadLocal.get());
    }
} 

线程池中的线程进行值传递

ThreadLocal的常见方法的实现

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
                        //找到对应map里面entry的位置
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

总结：

• 强引用：是指创建一个对象并把这个对象赋值给一个引用变量（new出的对象、等于号赋值）、内存不足也不会回收；
• 软引用：用于内存敏感高速缓存。内存足够不回收、内存不足就会回收；
• 弱引用：一旦发现弱引用对象就会回收、无论内存是否足够；
• 虚引用：相当于没有引用、主要用来跟踪对象被垃圾回收的活动

• 当B使用了A的对象后，即使A被置为null，但是GC仍然不会回收。因为B还持有对A的引用，而且还是强引用。
• 所以既不能回收，也不能利用使用，这就会造成内存泄漏。

A a = new A（）；
B b = new B(a);

ThreadLocal中的key引发的内存泄漏

解决：

• 使用弱引用；（解决ThreadLocalMap中的key内存泄漏）
• 通过显式的置为null消除强引用（解决ThreadLocalMap中的value内存泄漏）