ThreadLocal作用以及原理解析

ThreadLocal作用

对于多个线程访问一个共享变量的时候，我们往往要通过加锁的方式进行同步，像这样

但是除此之外，其实还有另一种方式可以隔绝线程对于共享变量读写的独立性。那就是ThreadLocal。如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有一块独立的空间，当多个线程操作这个变量的时候，实际上操作的都是自己线程所属的空间的那个变量，不会对其他线程有影响，也不会被其他线程影响，因为彼此都是互相独立的。因此想要保证线程安全，也可以把共享变量放在ThreadLocal中。总体来说就是，ThreadLocal提供了线程内存储变量的能力，这些变量不同之处在于每一个线程读取的变量是对应的互相独立的。通过get和set方法就可以得到当前线程对应的值。

接下来看一个例子

public class ThreadLocalDemo1 {

    public static int value = 0;
   static ThreadLocal<Object> local = new ThreadLocal<>();
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"---线程初始值:"+local.get());
                    local.set("我是"+Thread.currentThread().getName());
                    System.out.println(Thread.currentThread().getName()+"---线程修改值:"+local.get());
                }
            },"线程"+i).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程"+local.get());
    }

}

运行结果

线程1---线程初始值:null
线程4---线程初始值:null
线程3---线程初始值:null
线程0---线程初始值:null
线程2---线程初始值:null
线程0---线程修改值:我是线程0
线程3---线程修改值:我是线程3
线程4---线程修改值:我是线程4
线程1---线程修改值:我是线程1
线程2---线程修改值:我是线程2
主线程null

上面这段代码，运行结果印证了我们开头说的那些关于ThreadLocal的论述，分析一下代码，可以看到，我们这里只有一个ThreadLocal对象，即local，我们一共有五个线程，线程0对local进行set值之后，线程2再get却还是null，但是线程0自己再get，却可以拿到自己设置的那个值 我是线程0 ，别的线程是拿不到这个值的，而且代码的最后，在所有的线程都运行完毕之后，在主线程对local进行get操作，拿到的值却还是null。这就印证了这个结论，每个线程都只能拿到自己线程所属的值，线程之间是相互独立的

ThreadLocal原理

set方法

话不多说，我们直接上源码。首先先看看ThreadLocal的set方法

public void set(T value) {
    //先获取当前线程
        Thread t = Thread.currentThread();
    //看看当前线程是不是已经设置过值了
        ThreadLocalMap map = getMap(t);
    //如果设置过了,就覆盖原来的值
        if (map != null)
            map.set(this, value);
        else
            //如果当前线程第一次设置值 那就创建一个存储区域(Map)
            createMap(t, value);
    }

继续看看 createMap(t, value)方法的源码

 /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

根据注释，和源码里面可以看到，createMap方法里面实际上就是new了一个ThreadLocalMap对象，创建了一个与ThreadLocal关联的map，然后把当前Thread中的一个ThreadLocal引用和要设置的值放进去。请注意t.threadLocals是定义在Thread类里的，代码如下

  //这一段是定义在Thread类中的
ThreadLocal.ThreadLocalMap threadLocals = null;

继续看看ThreadLocalMap里有啥

  /**
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
         */
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

可以看到，ThreadLocalMap里维护了一个Entry数组，将Thread里面的ThreadLocal.ThreadLocalMap变量引用并且通过一系列的hashcode操作，作为key。接下来继续看看Entry

    /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

Entry继承WeakReference,使用弱引用，可以将ThreadLocal对象的生命周期和线程生命周期解绑，持有对ThreadLocal的弱引用，可以使得ThreadLocal在没有其他强引用的时候被回收掉，这样可以避免因为线程得不到销毁导致ThreadLocal对象无法被回收。

以上就差不多是整个set方法的源码了，有了以上的了解，再看get的就会很简单

get方法

  public T get() {
      //获取当前线程，并以线程引用为key去ThreadLocalMap中获取值
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
      //如果为不为空，就以当前线程对应的Thread中的ThreadLocal引用 进行hash计算 拿到值返回
        if (map != null) {
            //拿到引用去获取值
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
      //为空就返回一个初始值
        return setInitialValue();
    }

//对应getMap方法 返回的是当前线程的threadLocals引用
  ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
//上面的getEntry方法
      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);
        }

//get中的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;
    }

可以看到,如果你一个线程在get之前没有set,也是会给你以当前线程创建一个与你线程对应的createMap的,只不过key是当前线程下的ThreadLocalMap引用,value为null,因为

 T value = initialValue();

这一行的的initialValue()方法是这样的

  protected T initialValue() {
        return null;
    }

其实还有remove方法啥的,原理都差不多.。所以就不赘述了。

总结

ThreadLocal为每个线程都定义了一个ThreadLocalMap类型名为threadLocals的变量，有点类似于HashMap，但是严格意义上来说不是，只是将其类比为Map结构，key为当前线程中的threadLocals的this引用，value是设置的值。所以每个线程都有不同的key，所能获取到的值也是不一样的，就是利用这种思想去保证值对每个线程的独立性。因为不管是get还是set之前都会有currentThread这个操作，所以每个线程都只能取到自己线程对应的值。