从头认识多线程-4.4 ThreadLocal的实现原理

从头认识多线程-4.4 ThreadLocal的实现原理

这一章节我们来讨论一下ThreadLocal的实现原理。

1.ThreadLocal的存储

一般可以认为是ThreadLocalMap这个内部类来存储，但是如果更加深入一层，其实他的存储是Entry类的可变数组，这个跟HashMap的存储比较相似

2.为什么在使用ThreadLocal的时候需要初始化？

ThreadLocal的初始化源码：

 /**
     * Returns the current thread's "initial value" for this
     * thread-local variable.  This method will be invoked the first
     * time a thread accesses the variable with the {@link #get}
     * method, unless the thread previously invoked the {@link #set}
     * method, in which case the <tt>initialValue</tt> method will not
     * be invoked for the thread.  Normally, this method is invoked at
     * most once per thread, but it may be invoked again in case of
     * subsequent invocations of {@link #remove} followed by {@link #get}.
     *
     * <p>This implementation simply returns <tt>null</tt>; if the
     * programmer desires thread-local variables to have an initial
     * value other than <tt>null</tt>, <tt>ThreadLocal</tt> must be
     * subclassed, and this method overridden.  Typically, an
     * anonymous inner class will be used.
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

其实我们一打开源码就不难看见，其实在初始化之初，直接就是返回null，所以在没有初始化的情况下，直接get里面的元素，是返回null

3.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);
    }

从源码看来，他使用了ThreadLocalMap作为容器，然后把值放到里面去，我们在进入ThreadLocalMap去看看
ThreadLocalMap是在ThreadLocal里面实现的内部类，由于代码太长这里就不贴出来，笔者曾看到有文章说ThreadLocalMap跟HashMap的实现是一样，然后仔细对比ThreadLocalMap跟HashMap的实现，是非常的相似，都是使用Entry数组来实现存储，然后遍历里面的元素，估计当时设计的思路都差不多，但是HashMap在Entry的实现上，明显比ThreadLocalMap的Entry要强。

4.get方法的实现，下面将解释为什么没有初始化，返回null

源码：

 /**
     * 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();
    }

讲到get方法，我们深入debug，发现：
我们点击进去setInitialValue方法，

/**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    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;
    }

可以看到他返回的是value，而value，也就是初始化方法initialValue()的返回值，这里就解释了为什么没有初始化的时候，get返回的是null

5.为什么多线程情况下，每一个线程只会计算自己工作内存里面的变量副本？

我们分别看看set和get方法里面的某一两句
set方法

Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);

get方法

Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);

getMap方法

  /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

在两个方法里面，一开始都会出现这两句代码，这里我们点击去getmap方法，看见，里面出现了t.threadLocals，使用变量副本的原因就在这一句里面。

6.remove方法

源码：

/**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * <tt>initialValue</tt> method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

remove方法主要是去掉某个线程的变量副本，使得这个线程不能够在使用变量副本进行计算。

总结：我们这一章节简单的描述了ThreadLocal的实现原理。

这一章节就到这里，谢谢。

---

我的github：https://github.com/raylee2015/DeepIntoThread

目录：http://blog.csdn.net/raylee2007/article/details/51204573