ThreadLocal底层原理

た入场券 2022-02-26 15:06 369阅读 0赞

## **先总述，后分析** ##

深挖过threadLocal之后，一句话概括：Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。所以ThreadLocal的应用场合，最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

数据隔离的秘诀其实是这样的，Thread有个TheadLocalMap类型的属性，叫做threadLocals，该属性用来保存该线程本地变量。这样每个线程都有自己的数据，就做到了不同线程间数据的隔离，保证了数据安全。

接下来采用jdk1.8源码进行深挖一下TheadLocal和TheadLocalMap。

## **ThreadLocal是什么** ##

早在JDK 1.2的版本中就提供[Java][].lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。

所以，在Java中编写线程局部变量的代码相对来说要笨拙一些，因此造成线程局部变量没有在Java开发者中得到很好的普及。

## **Thread同步机制的比较** ##

ThreadLocal和线程同步机制相比有什么优势呢？

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

Spring使用ThreadLocal解决线程安全问题我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了。

一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程。

## **原理** ##

ThreadLocal，连接ThreadLocalMap和Thread。来处理Thread的TheadLocalMap属性，包括init初始化属性赋值、get对应的变量，set设置变量等。通过当前线程，获取线程上的ThreadLocalMap属性，对数据进行get、set等操作。

ThreadLocalMap，用来存储数据，采用类似hashmap机制，存储了以threadLocal为key，需要隔离的数据为value的Entry键值对数组结构。

ThreadLocal，有个ThreadLocalMap类型的属性，存储的数据就放在这儿。  
      ThreadLocal、ThreadLocal、Thread之间的关系：ThreadLocalMap是ThreadLocal内部类，由ThreadLocal创建，Thread有ThreadLocal.ThreadLocalMap类型的属性。源码如下：

Thread的属性：

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

** ThreadLocal和ThreadLocalMap：**

public class ThreadLocal<T> {
       
        static class ThreadLocalMap {

** 由ThreadLocal对Thread的TreadLocalMap进行赋值**

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

**ThreadLocal的接口方法**

ThreadLocal类核心方法set、get、initialValue、withInitial、setInitialValue、remove：

protected T initialValue() {
            return null;
        }
     
       
        public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
            return new SuppliedThreadLocal<>(supplier);
        }
     
      
        public ThreadLocal() {
        }
     
       
        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();
        }
     
       
        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;
        }
     
       
        public void set(T value) {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
        }
     
       
         public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }

*  initialValue返回该线程局部变量的初始值。该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。
 *  withInitial提供一个Supplier的lamda表达式用来当做初始值，java8引入。
 *  setInitialValue设置初始值。在get操作没有对应的值时，调用此方法。private方法，防止被覆盖。过程和set类似，只不过是用initialValue作为value进行设置。
 *  set设置当前线程对应的线程局部变量的值。先取出当前线程对应的threadLocalMap，如果不存在则用创建一个，否则将value放入以this，即threadLocal为key的映射的map中，其实threadLocalMap内部和hashMap机制一样，存储了Entry键值对数组，后续会深挖threadLocalMap。
 *  get该方法返回当前线程所对应的线程局部变量。和set类似，也是先取出当前线程对应的threadLocalMap，如果不存在则用创建一个，但是是用inittialValue作为value放入到map中，且返回initialValue，否则就直接从map取出this即threadLocal对应的value返回。
 *  remove将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。需要注意的是，如果remove之后又调用了get，会重新初始化一次，即再次调用initialValue方法，除非在get之前调用set设置过值。

## ThreadLocalMap简介 ##

看名字就知道是个map，没错，这就是个hashMap机制实现的map，用Entry数组来存储键值对，key是ThreadLocal对象，value则是具体的值。值得一提的是，为了方便GC，Entry继承了WeakReference，也就是弱引用。里面有一些具体关于如何清理过期的数据、扩容等机制，思路基本和hashmap差不多，有兴趣的可以自行阅读了解，这边只需知道大概的数据存储结构即可。

static class ThreadLocalMap {
    
            static class Entry extends WeakReference<ThreadLocal<?>> {
                
                Object value;
     
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }

## **实例** ##

值得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>。API方法也相应进行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。我们自己就可以提供一个简单的实现版本：

package com.test;  
          
        public class TestNum {  
            // ①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值  
            private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>() {  
                public Integer initialValue() {  
                    return 0;  
                }  
            };  
          
            // ②获取下一个序列值  
            public int getNextNum() {  
                seqNum.set(seqNum.get() + 1);  
                return seqNum.get();  
            }  
          
            public static void main(String[] args) {  
                TestNum sn = new TestNum();  
                // ③ 3个线程共享sn，各自产生序列号  
                TestClient t1 = new TestClient(sn);  
                TestClient t2 = new TestClient(sn);  
                TestClient t3 = new TestClient(sn);  
                t1.start();  
                t2.start();  
                t3.start();  
            }  
          
            private static class TestClient extends Thread {  
                private TestNum sn;  
          
                public TestClient(TestNum sn) {  
                    this.sn = sn;  
                }  
          
                public void run() {  
                    for (int i = 0; i < 3; i++) {  
                        // ④每个线程打出3个序列值  
                        System.out.println("thread[" + Thread.currentThread().getName() + "] --> sn["  
                                 + sn.getNextNum() + "]");  
                    }  
                }  
            }  
        }

通常我们通过匿名内部类的方式定义ThreadLocal的子类，提供初始的变量值，如例子中①处所示。TestClient线程产生一组序列号，在③处，我们生成3个TestClient，它们共享同一个TestNum实例。运行以上代码，在控制台上输出以下的结果：

thread\[Thread-0\] --> sn\[1\]  
thread\[Thread-1\] --> sn\[1\]  
thread\[Thread-2\] --> sn\[1\]  
thread\[Thread-1\] --> sn\[2\]  
thread\[Thread-0\] --> sn\[2\]  
thread\[Thread-1\] --> sn\[3\]  
thread\[Thread-2\] --> sn\[2\]  
thread\[Thread-0\] --> sn\[3\]  
thread\[Thread-2\] --> sn\[3\]

考察输出的结果信息，我们发现每个线程所产生的序号虽然都共享同一个TestNum实例，但它们并没有发生相互干扰的情况，而是各自产生独立的序列号，这是因为我们通过ThreadLocal为每一个线程提供了单独的副本。

[Java]: http://lib.csdn.net/base/java