ThreadLocal主要是为了解决线程安全性问题的

非线程安全举例

public class ThreadLocalDemo {// 非线程安全的private static final SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");public static Date parse(String strDate) throws ParseException {return sdf.parse(strDate);}public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(10);for (int i = 0; i < 20; i++) {executorService.execute(() -> {try {System.out.println(parse("2021-05-30 20:21:20"));} catch (ParseException e) {e.printStackTrace();}});}}
}

以上代码，构造了一个SimpleDateFormat对象，然后在main线程中，开启了20个线程执行时间的格式化，其输出结构部分如下:

可以看到，程序有部分线程打印出了结果，但结果也都不一样，并且也有部分报了异常。

分析:这是由于SimpleDateFormat在这里设置的是一个全局变量，多个线程共用的时候，必然涉及到共享资源的抢占，其parse方法内部对字符串的处理的操作就是非原子性的，因此就会出现真正执行的时候，拿到的最终字符串无法确定，导致以上报错。

思考: 如何修改? 使用ThreadLocal将DateFormat设置为线程安全的，保证每个线程的操作都是原子的。

ThreadLocal应用

public class ThreadLocalDemo {private static final ThreadLocal<DateFormat> dateFormatThreadLocal = new ThreadLocal<>();public static Date parse(String strDate) throws ParseException {DateFormat dateFormat = dateFormatThreadLocal.get();if (dateFormat == null ) {dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");dateFormatThreadLocal.set(dateFormat);}return dateFormat.parse(strDate);}public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(10);for (int i = 0; i < 20; i++) {executorService.execute(() -> {try {System.out.println(parse("2024-04-12 15:12:20"));} catch (ParseException e) {e.printStackTrace();}});}}
}

结果输出

ThreadLocal常用方法

set()

在当前线程范围内，设置一个值存储在ThreadLocal中，这个值仅对当前线程可见

相当于在当前线程范围内建立了副本

get()

从当前线程范围内取出set()方法设置的值

remove()

移除当前线程范围内的值

ThreadLocal原理猜想

1. 能够实现线程的隔离，当前保存的数据，只会存储在当前的线程范围内->线程内私有的

2.有一个存储结构

3.key->保存当前线程

ThreadLocal源码分析

1.初始化ThreadLocalMap

        static class Entry extends WeakReference<ThreadLocal<?>> {/** The value associated with this ThreadLocal. */Object value;Entry(ThreadLocal<?> k, Object v) {super(k);value = v;}}

作为一个静态内部类，在类加载时，就会加载该线程的一个ThreadLocalMap.Entry

注意:在这里Entry采用的是一个弱引用对象，为什么要采用弱引用对象呢?这是由于ThreadMap是和线程绑在一起的，如果这个线程没有被销毁，而我们又已经不会在使用ThreadLocal引用了，那么key-value的键值对就会一直在map中存在，这对于程序来说，就出现了内存泄漏。为了避免这种情况，只要将Key设置为弱引用，那么当发生GC的时候，就会自动的把弱引用给清理掉了。

2. set主逻辑源码

   public void set(T value) {// 1. 获得当前线程tThread t = Thread.currentThread();// 2. 取当前线程的ThreadLocalMapThreadLocalMap map = getMap(t);if (map != null) {// 2.1 如果map不为空， 则设置当前ThreadLocal变量的value值map.set(this, value);} else {// 2.2 若map为空，则创建一个ThreadLocalMapcreateMap(t, value);}}

1.2 当前线程的map不为空时，如何进行set值

    private void set(ThreadLocal<?> key, Object value) {Entry[] tab = table;int len = tab.length;// 2.1.1 根据当前key获得索引值int i = key.threadLocalHashCode & (len-1);// 2.1.2 循环entry数组for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {// 2.1.3 entry不为空 获得当前entry数组元素的keyThreadLocal<?> k = e.get();// 2.1.4 若相等，则赋值valueif (k == key) {e.value = value;return;}// 2.1.5若当前entry中为空 则进行替换空余的数组if (k == null) {replaceStaleEntry(key, value, i);return;}}tab[i] = new Entry(key, value);int sz = ++size;if (!cleanSomeSlots(i, sz) && sz >= threshold)// 2.1.6 这里主要是对Entry数组的一个扩容知识 rehash();}

分析:当前entry为空(key值可能被GC回收了)，那么该条数据就可能为脏数据，脏Entry，只有value有值 key为null  就执行replaceStaleEntry方法(注:2.1.6在这里不再展开，主要是Entry数组的一个扩容)

     private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) {Entry[] tab = table;int len = tab.length;Entry e;// a.当前key的索引int slotToExpunge = staleSlot;// b. 向前查询脏Entry  for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len))if (e.get() == null)slotToExpunge = i;// c. 向后查找可覆盖的Entryfor (int i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {ThreadLocal<?> k = e.get();if (k == key) {e.value = value;// d.进行交换 避免Entry中数据重复tab[i] = tab[staleSlot];tab[staleSlot] = e;if (slotToExpunge == staleSlot)slotToExpunge = i;// e.从前往后清理脏EntrycleanSomeSlots(expungeStaleEntry(slotToExpunge), len);return;}if (k == null && slotToExpunge == staleSlot)slotToExpunge = i;}// f. 没有找到可覆盖的Entry，则清理当前索引的value重新赋值tab[staleSlot].value = null;tab[staleSlot] = new Entry(key, value);// h.清理查询到的脏Entryif (slotToExpunge != staleSlot)cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);}

该段代码其实会分为4种情况

a. 向前查找有脏Entry 向后查找到可覆盖的Entry（这里是由于存储的时候会有哈希冲突，因此向后可能会有相同的key值）

b.向前有脏Entry向后未找到可覆盖的Entry（则直接在当前索引位置直接赋值新的Entry）

c.向前没有脏Entry向后找到可覆盖的Entry

d.向前没有脏Entry向后未找到可覆盖的Entry

分析:上述set值，一定程度上避免了Entry数组的内存泄漏，因为可以向前检索到脏Entry并进行清理，但是如果向前查找提前停了下来，那么前面仍还有脏Entry未扫描到，那么仍会有部分内存泄漏。真正全部清理需要每次使用后调用remove方法

1.3 当前线程的Map为空时，进行创建并set值

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

       ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {// 2.2.1 初始化一个16长度大小的数组table = new Entry[INITIAL_CAPACITY];// 2.2.2 设置下标索引 采用的是线性探测法int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);// 2.2.3 将Entry设置到该数组索引处table[i] = new Entry(firstKey, firstValue);size = 1;// 2.2.4 设置阈值为10setThreshold(INITIAL_CAPACITY);}

设置索引的地方主要是采用线性探测法来解决哈希冲突，找到一篇不错的博客，感兴趣可以参考博客:ThreadLocalMap线性探测法解决hash冲突_thread t = thread.currentthread(); threadlocalmap -CSDN博客

3. get主逻辑源码

    public T get() {Thread t = Thread.currentThread();// 1.首先获得当前线程的ThreadLocalMapThreadLocalMap map = getMap(t);if (map != null) {// 2.拿到Entry如何Entry不为空的情况下 直接返回值ThreadLocalMap.Entry e = map.getEntry(this);if (e != null) {@SuppressWarnings("unchecked")T result = (T)e.value;return result;}}// 3. 如果弱引用key被回收了，则会重新创建当前线程的Entry,并赋值return setInitialValue();}

4.remove主逻辑源码

     private void remove(ThreadLocal<?> key) {Entry[] tab = table;int len = tab.length;int i = key.threadLocalHashCode & (len-1);for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {if (e.get() == key) {// 遍历当前Entry数组，全部清理掉e.clear();expungeStaleEntry(i);return;}}}

ThreadLocal总结

1.ThreadLocal主要是为了线程安全，避免多线程的资源共享，线程间的资源互相隔离

2..ThreadLocal的注意点: ThreadLocal可能会造成内存泄漏，因此在每次使用完后，调用remove进行清理

3.为什么ThreadLocal的key值是弱应用，而value值是强引用? 在ThreadLocalMap初始化时已经说明了key值为什么要采用弱引用，那么value值为什么不能设置为弱引用呢。假设Entry的key所引用的ThreadLocal对象还被其他的引用对象强引用着，那么这个ThreadLocal对象就不会被GC回收，但如果value是弱引用且不被其他引用对象引用着，那么GC的时候就会被回收掉了。那线程通过ThreadLocal获取value的时候就会获得null，ThreadLocal显然就是用来关联value的，value才是我们要保存的值，如果value都没了，还用ThreadLocal干嘛。所以value不能是弱引用