万物皆Map-一文带你了解ThreadLocal

文章要点：
1.ThreadLocal概念
2.ThreadLocal的使用示例
3.ThreadLocal的底层原理
4.ThreadLocal的内存泄漏

一.什么是ThreadLocal？

ThreadLocal是一种线程的隔离机制，保障了多线程环境下对于共享变量访问的安全性。
ThreadLocal为共享变量在每个线程中都创建了一个副本(见下图示例)，那么每个线程可以访问自己内部的副本变量

public class ThreadLocalDemo {

    //初始化ThreadLocal的值为10
    private static final ThreadLocal<Integer> dateLocal = ThreadLocal.withInitial(() -> 10);

    public static void main(String[] args) {
        //定义线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(() -> {
            //修改当前线程的ThreadLocal值为5
            dateLocal.set(5);
            System.out.println(Thread.currentThread().getName() + ":" + dateLocal.get());
        });
        executorService.shutdown();
        //获取主线程的数据
        System.out.println(Thread.currentThread().getName() + ":" + dateLocal.get());
    }
}

运行结果:主线程不会读取到子线程修改的值

同样主线程修改的值不会被子线程读取。

运行结果:

即线程读取ThreadLocal中的变量，相当于获取的是本地变量，对变量修改不会被其他线程感知。

与Synchronized的区别：
1.Synchronized则是一种基于Happens-Before规则里的监视器锁规则从而保证同一个时刻只有一个线程能够对共享变量进行更新。
2.ThreadLocal是一种通过创建变量副本实现共享变量安全访问的线程隔离机制

二.ThreadLocal应用示例

以SimpleDateFormat（线程不安全）为例：

public class DateFormatTest {
    private static final SimpleDateFormat simpleDateFormat =
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static Date parse(String dateString) {
        Date date = null;
        try {
            date = simpleDateFormat.parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(20);

        for (int i = 0; i < 20; i++) {
            executorService.execute(()->{
                System.out.println(parse("2024-02-01 23:34:30"));
            });
        }
        executorService.shutdown();
    }
}

结果：刚开始正常，一段时间报错

使用ThreadLocal改造成线程安全的：

public class DateFormatTest {

    private static final ThreadLocal<SimpleDateFormat> dateFormatThreadLocal =
            ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    public static Date parse(String dateString) {
        Date date = null;
        try {
            date = dateFormatThreadLocal.get().parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 20; i++) {
            executorService.execute(()->{
                System.out.println(parse("2024-02-01 23:34:30"));
            });
        }
        executorService.shutdown();
    }
}

三.ThreadLocal底层原理（源码）:

public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

tatic class ThreadLocalMap {
        
        private static final int INITIAL_CAPACITY = 16; //初始化容量
        private Entry[] table; //ThreadLocalMap数据真正存储在table中
        private int size = 0; //ThreadLocalMap条数
        private int threshold; // 默认为0,达到这个大小，则扩容
        //类Entry的实现
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        //构造函数
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY]; //初始化table数组，INITIAL_CAPACITY默认值为16
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); //key和16取得哈希值
            table[i] = new Entry(firstKey, firstValue);//创建节点，设置key-value
            size = 1;
            setThreshold(INITIAL_CAPACITY); //设置扩容阈值
        }
    }

set方法：

public void set(T value) {
        Thread t = Thread.currentThread(); //获取当前线程t
        ThreadLocalMap map = getMap(t);  //根据当前线程获取到ThreadLocalMap
        if (map != null)  //如果获取的ThreadLocalMap对象不为空
            map.set(this, value); //K，V设置到ThreadLocalMap中
        else
            createMap(t, value); //创建一个新的ThreadLocalMap
    }
    
     ThreadLocalMap getMap(Thread t) {
       return t.threadLocals; //返回Thread对象的ThreadLocalMap属性
    }

    void createMap(Thread t, T firstValue) { //调用ThreadLocalMap的构造函数
        t.threadLocals = new ThreadLocalMap(this, firstValue); //this表示当前类ThreadLocal
    }

get方法:

public T get() {
        //1、获取当前线程
        Thread t = Thread.currentThread();
        //2、获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        //3、如果map数据不为空，
        if (map != null) {
            //3.1、获取threalLocalMap中存储的值
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //如果是数据为null，则初始化，初始化的结果，TheralLocalMap中存放key值为threadLocal，值为null
        return setInitialValue();
    }
 
 
private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

remove方法(避免内存泄漏的核心方法)：

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

总结：ThreadLocal实质是一个KV结构，底层维护了一个Entry数组，Entry的元素是以ThreadLocal对象本身为key，存储的元素为value的键值对。其中，key是WeakReference。

jvm虚拟机引用的几种类型：
强引用：其实就是咱们一般用“=”的赋值行为，如 Student s = new Student(),只要强引用还在，对象就不会被回收。
软引用：不是必须存活的对象，jvm在内存不够的情况下即将内存溢出前会对其进行回收。例如缓存。
弱引用：非必须存活的对象，引用关系比软引用还弱，无论内存够还是不够，下次的GC一定会被回收。
虚引用：别名幽灵引用或者幻影引用。等同于没有引用，唯一的目的是对象被回收的时候会受到系统通知。

四.内存泄漏

根据ThreadLocal的底层原理的描述，不难发现，会存在Entry的key被回收，而value还未被回收的情况，这个value就永远无法被访问了(见下图)，按道理也该被回收。但是由于entry还在强引用value。那么此时value就无法被回收，此时内存泄漏就出现了。本质原因是因为value成为了一个永远无法被访问也无法被回收的对象。

如何避免：

1.每次使用完毕之后记得调用一下remove()方法清除数据。
2.ThreadLocal变量尽量定义成static final类型，避免频繁创建ThreadLocal实例。这样可以保证程序中一直存在ThreadLocal强引用，也能保证任何时候都能通过ThreadLocal的弱引用访问Entry的value值，从而进行清除。