详解ThreadLocal

为什么出现ThreadLocal ？

在多线程环境下，如果多个线程同时修改一个公共变量，可能会出现线程安全问题，即该变量的最终结果可能出现异常。为了解决线程安全问题，JDK提供了很多技术手段，比如使用synchronized或Lock来给访问公共资源的代码上锁，保证了代码的原子性。但在高并发的场景中，如果多个线程同时竞争一把锁，这时会存在大量的锁等待，可能会浪费很多时间，让系统的响应时间变慢。因此，JDK还提供了另外一种用空间换时间的新思路：ThreadLocal。它的核心思想是：共享变量在每个线程都有一个副本，每个线程操作的都是自己的副本，对另外的线程没有影响。

ThreadLocal是什么？

ThreadLocal是一个与线程相关的类，但它本身并不是一个Thread。

这个类可以提供线程局部变量，与普通变量有所不同。虽然你可以实例化一个ThreadLocal对象，但当每个线程访问或设置它时，它们实际上是在操作本线程内的该对象的副本。这也意味着，这个对象在不同的线程中，副本的值是不一样的

ThreadLocal是Java提供的一个线程本地变量的实现机制，其核心目的是让每个线程拥有自己独立的变量副本。这样，在多线程环境下，每个线程都可以独立地改变自己的副本，而不会影响其他线程的副本，从而实现了线程数据隔离，避免了线程安全问题。

如何使用？

public class ThreadLocalExample {
    private static ThreadLocal<String> threadLocalVar = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 设置线程1中的本地变量值
                threadLocalVar.set("Hello");
                // 打印本地变量
                System.out.println("Thread 1 value: " + threadLocalVar.get());
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 设置线程2中的本地变量值
                threadLocalVar.set("World");
                // 打印本地变量
                System.out.println("Thread 2 value: " + threadLocalVar.get());
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
}

我们创建了两个线程（t1和t2），每个线程都设置了不同的本地变量值，并打印出来。通过使用ThreadLocal类，每个线程都有自己独立的本地变量副本，因此它们之间不会相互干扰。

输出结果

Thread 1 value: Hello
Thread 2 value: World

注意：

ThreadLocal 和集合类一样，在创建时需要指定类型，上如图就指定的 String 类型
ThreadLocal 的读写和设置不是用的等于号 , 而是要使用该ThreadLocal 的 set 和 get 方法

ThreadLocal如何实现？

public class ThreadLocal<T> {
    public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 根据当前ThreadLocal对象获取对应的Entry对象
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                // 返回Entry对象的值作为结果
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 如果map为空或者Entry对象为空，则设置初始值并返回
        return setInitialValue();
    }
    
    ThreadLocalMap getMap(Thread t) {
        // 返回当前线程的threadLocals成员变量
        return t.threadLocals;
    }
    
    public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 将给定的ThreadLocal对象和对应的值存储到table中
            map.set(this, value);
        } else {
            // 如果map为空，则创建一个新的ThreadLocalMap对象并存储给定的值
            createMap(t, value);
        }
    }
    ThreadLocalMap getMap(Thread t) {
        // 返回当前线程的threadLocals成员变量
        return t.threadLocals;
    }
}

public class Thread implements Runnable {
    //...
    // 定义一个ThreadLocalMap类型的成员变量threadLocals，用于存储当前线程的ThreadLocal对象及其对应的值
    ThreadLocal.ThreadLocalMap threadLocals = null;   
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
 
}

public class ThreadLocal<T> {
    static class ThreadLocalMap {
        private Entry[] table;  // 存储键值对的Entry数组
        static class Entry extends WeakReference<ThreadLocal<?>> {
          Object value;
          Entry(ThreadLocal<?> k, Object v) {
              super(k);  // 使用super()方法创建弱引用，key值为ThreadLocal对象
              value = v;
          }
        }
        //...
        private Entry getEntry(ThreadLocal<?> key) {
          int i = key.threadLocalHashCode & (table.length - 1);  // 计算索引位置
          Entry e = table[i];
          if (e != null && e.get() == key)
              return e;
          else
              return getEntryAfterMiss(key, i, e);  // 如果未找到，则进行查找操作
        }
        private void set(ThreadLocal<?> key, Object value) {
            // 将给定的ThreadLocal对象和对应的值存储到table中
        }
         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) {
               e.clear();
               expungeStaleEntry(i);
               return;
            }
          }
        }
    }
}

ThreadLocalMap 本质是一个<key,value>形式的节点组成的数组，

ThreadLocalMap 的节点是一个静态内部类 Entry，它继承自 WeakReference<ThreadLocal<?>>。这意味着每个 Entry 对象都是一个弱引用，其引用的是 ThreadLocal 类型的对象作为键（key）。值为代码放入的值