ThreadLocal原理解析（1）：数据存取

客官°小女子只卖身不卖艺 2022-06-09 00:24 128阅读 0赞

转载请注明出处：[【huachao1001的专栏：http://blog.csdn.net/huachao1001】][huachao1001_http_blog.csdn.net_huachao1001]

## 本文是源码解析是基于`JDK 1.7` ##

> 注意：`Android`内使用的`ThreadLocal`跟`JDK`内部的`ThreadLocal`具体实现有区别。但是他们所做的功能是一致的，只是`android`针对`ThreadLocal`做了优化。但这不影响我们学习ThreadLocal的实现思想。

`ThreadLocal`的使用相信大家都比较熟悉，但是`ThreadLocal`内部是如何做到为不同线程保存不同的副本的呢？能看到这篇文章，说明你也跟我一样好奇。接下来我们一层一层解开`ThreadLocal`的面纱吧~

# 1. 涉及到的几个重要类 #

`ThreadLocal`里面的实现，主要涉及到以下几个重要类：

>  *  Thread：大家很熟悉的线程类，一个`Thread`类自然代表一个线程。
>  *  ThreadLocal：既然本文是要解析`ThreadLocal`类，自然就离不开这个类啦~。
>  *  ThreadLocalMap：可以看成一个`HashMap`，但是它本身具体的实现并没有实现继承`HashMap`甚至跟`java.util.Map`都沾不上一点关系。只是内部的实现跟`HashMap`类似（通过哈希表的方式存储）。
>  *  ThreadLocalMap.Entry：把它看成是保存键值对的对象，其本质上是一个`WeakReference<ThreadLocal>`对象。

主要涉及到的类暂时只有这些，其中`ThreadLocalMap`和`ThreadLocalMap.Entry`的源码解析留到下一篇文章讲，在本文中，我们暂时不去牵扯它们的实现细节，我们只需在心中默默地为`ThreadLocalMap`打上`HashMap`的标签，把它暂时先当成`HashMap`来看待，`ThreadLocalMap.Entry`看成是保存`<键,值>`的对象。

# 2. ThreadLocal数据存取 #

## 2.1 set函数 ##

我们知道，在使用`ThreadLocal`时，首先创建`ThreadLocal`对象，然后再调用其`set(T)`、`T get()`方法。我们从这些点切入，首先是构造函数如下：

public ThreadLocal() {
    }
     
      
       1 
       2 
      
     
      
       1 
       2

可以看到，构造函数没有任何实现。接下来我们再从`set`函数切入:

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17

代码整体流程很简单：

> 先拿到保存键值对的`ThreadLocalMap`对象实例`map`，如果`map`为空（第一次调用的时候`map`值为`null`），则去创建一个`ThreadLocalMap`对象并赋值给`map`，并把键值对保存到`map`中。

当然了，虽然整体流程看起来简单，其内部实现需要我们理清！

我们看到，首先是拿到当前线程实例`t`，任何将`t`作为参数获取`ThreadLocalMap`对象。为什么需要通过`Thread`类来获取`ThreadLocalMap`对象呢？`Thread`类和`ThreadLocalMap`有什么联系？这些需要我们去看看`getMap(Thread t)`函数的实现：

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
     
      
       1 
       2 
       3 
      
     
      
       1 
       2 
       3

我们看到，`getMap`的实现非常简单！！！仅仅返回`Thread`实例的`threadLocals`属性。`Thread`中的`ThreadLocalMap`属性声明如下：

ThreadLocal.ThreadLocalMap threadLocals = null;
     
      
       1 
      
     
      
       1

我们先理一理，`ThreadLocal`的`set(T)`函数中，首先是拿到当前线程`Thread`对象中的`ThreadLocalMap`对象实例`threadLocals` ，然后再将需要保存的值保存到`threadLocals`里面。

换句话说，每个线程引用的`ThreadLocal`副本值都是保存在当前线程`Thread`对象里面的。存储结构为`ThreadLocalMap`类型，`ThreadLocalMap`保存的键类型为`ThreadLocal`，值为`副本值`。

## 2.2 get函数 ##

有了`set`函数中的解析，我们对`get`函数就更容易理解了！先看看`get`函数源码：

/**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18

同样的道理，拿到当前线程`Thread`对象实例中保存的`ThreadLocalMap`对象`map`，然后从`map`中读取键为`this`（即`ThreadLocal`类实例）对应的值。

如果`map`不是`null`，直接从`map`里面读取就好，如果`map==null`，那么我们需要对当前线程`Thread`对象实例中保存的`ThreadLocalMap`对象`new`一下。即通过`setInitialValue`函数来创建，`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;
    }
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
      
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10

代码很简单，通过`createMap`来创建`ThreadLocalMap`对象，前面`set`函数里面创建`ThreadLocalMap`也是通过`createMap`来的，我们看看`createMap`具体实现：

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

这下对`ThreadLocal`的存取机制彻底清楚了吧！接下来一节我们以图形的形式做个总结。

# 3. 各个类之间关系 #

![ThreadLocal数据读取和设置过程][ThreadLocal]

上图中绿色部分就是读取数据过程，橙色就是设置数据过程。

在下一篇文章中，我们将一起阅读`ThreadLocalMap`源码，看看`ThreadLocalMap`内部是如何实现类似`Map`的功能的。

[huachao1001_http_blog.csdn.net_huachao1001]: http://blog.csdn.net/huachao1001
[ThreadLocal]: /images/20220609/87e24224da2144c1844fee98f35c440e.png