解锁Java多线程安全的秘密武器：探索ThreadLocal的神奇力量！

关于作者：CSDN内容合伙人、技术专家， 从零开始做日活千万级APP。
专注于分享各领域原创系列文章 ，擅长java后端、移动开发、人工智能等，希望大家多多支持。

一、导读

我们继续总结学习Java基础知识，温故知新。

二、概览

背景：当多线程访问共享可变数据时，涉及到线程间同步的问题，并不是所有时候，都要用到共享数据，所以就需要线程封闭出场了。
数据都被封闭在各自的线程之中，就不需要同步，这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭。

而ThreadLocal就提供了这样的功能。

ThreadLocal是Java中的一个类，用于在多线程环境下，为每个线程提供独立的变量副本。每个线程都可以独立地访问自己的变量副本，因为该独立变量属于当前线程，对其他线程而言是隔离的，不会与其他线程的副本产生冲突。

使用ThreadLocal可以解决多线程环境下共享变量的线程安全问题。通过将变量声明为ThreadLocal类型，在每个线程中独立创建变量的副本，从而保证了线程间的隔离。

三、使用场景

3.1 使用

可以用到的场景比较多，我们列举一些场景：
1、线程间数据隔离：通过将变量声明为ThreadLocal类型，每个线程都可以独立地操作自己的变量副本，避免了线程间的竞争和冲突。
2、上下文传递：使用ThreadLocal可以在不显式传递参数的情况下，在同一线程中共享数据。典型的应用场景包括数据库连接、用户身份验证等。
3、Web应用请求处理：使用ThreadLocal可以在请求处理过程中，方便地共享请求相关的数据，如用户信息、请求参数等。
4、时间格式化：在多线程环境下，日期时间格式化可能存在线程安全问题，为每个线程创建独立的日期时间格式化对象，确保线程安全的同时提高性能。

使用方式如下：

    private static final ThreadLocal<Long> iLong = new ThreadLocal<>();
    
    long l = iLong.get();
    iLong.set(10L);

3.2 缺点

需要注意的是，尽管ThreadLocal可以解决一些线程安全问题，但滥用ThreadLocal也可能导致内存泄漏和隐含的资源占用问题。

• 内存泄漏：当使用ThreadLocal的线程结束后，如果没有显式地调用ThreadLocal的remove()方法来清除对应的线程变量副本，那么这个副本将会一直存在于内存中，而不会被垃圾回收。如果此线程长时间存在或频繁创建销毁，那么就可能导致大量的无用副本占用内存，从而引发内存泄漏问题。

• 隐含的资源占用：由于ThreadLocal的变量副本与线程绑定，当使用ThreadLocal的线程长时间存在或频繁创建销毁时，每个线程都会持有自己的副本，这可能占用大量的资源，尤其是对于大对象或者大数据集的情况。如果没有及时清理和释放这些副本，可能会导致隐含的资源占用问题，降低系统的性能和可用性。

ThreadLocal针对一个线程只能记录一个变量，但是一个线程内可以通过多个ThreadLocal来记录多个变量。

四、原理解析

原理：
ThreadLocal利用每个线程独立持有自己的ThreadLocalMap对象的特性，实现了线程共享变量的隔离，ThreadLocalMap是 ThreadLocal 的静态内部类，用来存储线程所要保存的变量副本及对应的值，每个ThreadLocalMap是一个初始值为16的数组，里面每个数组的值是一个ThreadLocal的软引用，听起来有点绕，我们看2张图。

将数据在拆解一下，是这样的，一个thread 包含一个threadlocalmap, 每个map存储 threadlocal及value

4.1 为每个线程创建变量副本

我们知道每个Thread内部都有一个ThreadLocalMap对象，threadLocals 默认是空值，
threadLocals赋值的时机是当我们调用ThreadLocal的get、set时，我们看源码：

	public class Thread implements Runnable {
	    /* ThreadLocal values pertaining to this thread. This map is maintained
	     * by the ThreadLocal class. */
	    ThreadLocal.ThreadLocalMap threadLocals = null;
	}

    //createMap
    void createMap(Thread t, T firstValue) {
        //实例化一个新的ThreadLocalMap，并赋值给当前线程的成员变量threadLocals
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

4.2 源码

ThreadLocal.java

    // 返回当前线程所对应的线程局部变量
    public T get() {
        //获取当前线程
        Thread t = Thread.currentThread();
        //实际存储的数据结构类型
        ThreadLocalMap map = getMap(t);
        
        if (map != null) {
            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);
      //如果存在map就直接set，没有则创建map并set
      if (map != null)
          map.set(this, value);
      else
          createMap(t, value);
   }
  
    //getMap方法
    ThreadLocalMap getMap(Thread t) {
       //thred中维护了一个ThreadLocalMap
       return t.threadLocals;
    }
 
    //createMap
    void createMap(Thread t, T firstValue) {
        //实例化一个新的ThreadLocalMap，并赋值给线程的成员变量threadLocals
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

static class ThreadLocalMap

	ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	    初始化一个容量为16的Entry数组
	    table = new Entry[INITIAL_CAPACITY];
	    
	    用key即thradLocal对象的hash值计算存储在数组中的索引位置
	    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
	    
	    接着创建一个Entry对象，将key和value作为构造参数传入
	    table[i] = new Entry(firstKey, firstValue);
	
	    size = 1;
	    计算扩容因子，即当数组内元素达到数组大小的2/3时，会对数组进行扩容
	    setThreshold(INITIAL_CAPACITY);
	}

	通过hash计算索引时会存在hash冲突的问题，当数组容量较大时，hash冲突的概率降低
	虽然他不是以hashmap的形式存储，但是Entry对象里面也是设计成key/value的形式解决hash冲突的。
	所以你可以想象成ThreadLocalMap是个数组，而存储在数组里面的各个对象是以key/value形式
	的Entry对象

	static class Entry extends WeakReference<ThreadLocal<?>> {
	    /** The value associated with this ThreadLocal. */
	    Object value;
	    Entry(ThreadLocal<?> k, Object v) {
	        super(k);
	        value = v;
	    }
	}
	
	private void set(ThreadLocal<?> key, Object value) {
	    目的就是为了解决hash冲突，寻找数组插入下标的
	    int i = key.threadLocalHashCode & (len-1);
	
	    再往下是个for循环，里面是寻找可插入的位置，直到可以插入为止。
	    for (Entry e = tab[i];
	         e != null;
	         e = tab[i = nextIndex(i, len)]) {
	        ThreadLocal<?> k = e.get();
	        if (k == key) {
	            e.value = value;
	            return;
	        }
	        if (k == null) {
	            replaceStaleEntry(key, value, i);
	            return;
	        }
	    }
	}

ThreadLocalMap设计成数组，是因为线程里面可以有多个ThreadLocal对象，可能会初始化多个，这样存储的时候就需要数组了。

key如果不是WeakReference弱引用，则如果某个线程死循环，则ThreadLocalMap一直存在，引用住了ThreadLocal，导致ThreadLocal无法释放，同时导致value无法释放；当是WeakReference弱引用时，即使线程死循环，当创建ThreadLocal的地方释放了，ThreadLocalMap的key会同样被被释放，在调用getEntry时，会判断如果key为null，则会释放value，内存泄露则不存在。当然ThreadLocalMap类也提供remove方法，该方法会帮我们把当前ThreadLocal对应的Entry对象清除

五、 推荐阅读

【Java基础】原子性、可见性、有序性

【Java基础】java可见性之 Happens-before

【Java基础】java-android面试Synchronized

【Java基础】java-android面试-线程状态

【Java基础】线程相关

【Java基础】java 异常

【Java基础】java 反射

【Java基础】java 泛型

【Java基础】java注解

【Java基础】java动态代理

【Java基础】Java SPI

【Java基础】Java SPI 二 之 Java APT

【Java基础】 jvm 堆、栈、方法区 & java 内存模型

【Java基础】volatile关键字

【Java基础】线程同步类 CountDownLatch

【Java基础】CAS (Compare And Swap) 操作

【Java基础】AQS (AbstractQueuedSynchronizer) 抽象队列同步器