ThreadLocal源码解读

一.threadlocal概述

顾名思义线程本地存储，如果定义了一个threadlocal对象，每个线程往这个threadlocal对象中的读写是隔离的，可以为相同对象在不同线程中都创建不同的存储，因此如果多个线程都使用变量x，那线程本地存储会生成多个用于x的不同存储块。

二.threadlocal实现的大致思路

Thread类有一个ThreadLocal.threadLocalMap类型的实例变量threadlocals，也就是说每个线程都有一个threadLocalMap，threadLocalMap为定义在threadlocal内的静态内部类，虽是一个map但没有实现map接口，有自己独立的实现。threadLocalMap的是使用开放寻址线性探测的哈希表，节点Entry继承自弱引用WeakReference，本身为指向threadlocal的弱引用，有一个value属性用来存放放到threadlocal内的值。可以简单的认为key为threadlocal对象，值为放入threadlocal的具体值。每个线程往threadlocal中塞值的时候，都会以该threadlocal对象为key，往自己的threadlocalmap中存，读也是以某个threadlocal为引用，在自己的threadlocalmap中找对应的key，从而实现线程隔离。
图为Thread类中threadlocalmap实例变量：

ThreadLocal.ThreadLocalMap threadLocals = null;

三.API

image.png

threadLocalMap的api:

image.png

四.threadlocal API

get方法:

    public T get() {
        //获取当前线程的threadlocalmap
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        //如果线程中的threadlocalmap非空，则以这个threadlocal为key查询对应的value
        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;
    }
    //可以客户端自己继承threadlocal重写该类，否则如果没有set就get的话会抛出空指针错误
    protected T initialValue() {
        return null;
    }

set,remove:

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

可以看出get set remove方法都是获得当前线程的threadlocalmap，然后调用他的get set remove方法。

五.ThreadLocalMap详解

entry：

        static class Entry extends WeakReference> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

entry本身为一个弱引用，定义了一个类型为object的value

1.1为什么使用弱引用：
如果使用普通的key-value形式存储，那么就造成threadlocal对象的生命周期与线程一样长，因为总会存在thread->threadlocalmap->entry->threadlocal这样一条引用链存在，只要线程没被销毁，只要线程没有被销毁，那么节点在gc可达性分析中一直处于可达状态，无法被gc回收。而使用弱引用，如果threadlocal没有强引用可达，那么它不会活过下次gc，而该threadlocal对应的entry会失效，这位threadlocalmap垃圾清理提供了便利。

1.2类的成员变量和相应方法：

/**
         * 初始容量16，容量必须为2的幂
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 内部其实是entry类型的数组
         */
        private Entry[] table;

        /**
         * 表中entry的个数
         */
        private int size = 0;

        /**
         * 装载因子
         */
        private int threshold; // Default to 0

        /**
         * 最差的装载因子为2/3
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

threadlocalmap为使用线性探测的哈希表，nextIndex和prevIndex为获取表前一个元素和后一个元素的方法：

        /**
         * Increment i modulo len.
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * Decrement i modulo len.
         */
        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

由此可见threadlocalmap逻辑上来说为一个环形。

set方法:

 private void set(ThreadLocal key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            //key所在的槽位，使用该key的哈希值与上tab表的长度减一，相当于用len对threadLocalHashCode取模
            int i = key.threadLocalHashCode & (len-1);
            //若槽不为空，线性探测
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();
                //如果槽中entry对应的threadlocal对象与参数所传入对象相同，则直接替换
                if (k == key) {
                    e.value = value;
                    return;
                }
                //若槽中entry弱引用指向的threadlocal对象已经被gc回收，则该entry失效，替换
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //否则new一个entry
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

未完待续