ThreadLocal实现原理

1.ThreadLocal可称为线程局部变量or本地线程变量，该类的作用是为每个线程都创建一个变量副本, 每个线程都可以修改自己所拥有的变量副本, 而不会影响其他线程的副本. 其实这也是解决线程安全的问题的一种方法。

2.变量副本是什么时候“复制”到threadlocal中的呢？这里“复制”两个字用的很不专业。准确的说，应该是，变量副本【每个线程中保存的那个map中的变量】是怎么声明和初始化的？从源码可以看出，当线程中的threadlocalmap是null的时候，会调用createmap创建一个map。同时根据函数参数设置上初始值。也就是说，当前线程的threadlocalmap是在第一次调用set的时候创建map并且设置上相应的值的。如果没调用set之前直接调用get方法，也会初始化，调用的也是createmap方法。下面是set方法相关源码:

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    /**
       * 获取当前线程定义的ThreadLocal.ThreadLocalMap threadLocals = null;
     * @param t
     * @return
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    
map等于null情况 begin
    
    /**
        * 创建ThreadLocalMap实例对象
     * @param t
     * @param firstValue
     */
    void createMap(Thread t, T firstValue) {
    	// this 指的是  ThreadLocal 实例变量
        t.threadLocals = new ThreadLocalMap(this, firstValue); 
    }
    
    /**
     * 
     * @param firstKey
     * @param firstValue
     */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[INITIAL_CAPACITY]; // 数组容量16
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
    }
    
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }
    
    static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        // 数组是当前线程的成员变量ThreadLocal.ThreadLocalMap threadLocals 的成员变量，
        //用来存储当前线程所有ThreadLocal变量的实例
        private Entry[] table; 
        private static final int INITIAL_CAPACITY = 16; // table 数组初始化容量 
        private int size = 0; // 当前table存放的个数
        private int threshold; // Default to 0 // 何时扩容和此参数有关   len * 2 / 3;
        
map等于null情况 end    

map不等于null情况 begin
        private void set(ThreadLocal<?> key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            //顺环遍历
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) { 
                    e.value = value;
                    return;
                }
             //出现k等于null的情况为，还没有调用set的时候调用了get方法，
             //并将initialValue 初始化的值存储到数组中，详情请看get方法
                if (k == null) { 
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value); // 该ThreadLocal对象之前并没有存储过
            int sz = ++size;
            // threshold=len * 2 / 3;
            // 符合条件开始扩容  扩容大小为当前数组长度*2   
            if (!cleanSomeSlots(i, sz) && sz >= threshold) 
                rehash();
        }
        //获取下一个下标
	    private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }
        
        private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }
        //开始扩容
        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }
map不等于null情况 end

3.每个线程的变量副本是存储在哪里的？

   可以从ThreadLocal的get方法的源码中看出来，其中getmap函数是用t作为参数，这里t就是当前执行的线程。从而得知，get函数就是从当前线程的threadlocalmap中取出当前线程对应的变量的副本【注意，变量是保存在线程中的，而不是保存在ThreadLocal变量中】。当前线程中，有一个变量引用名字是threadLocals，这个引用是在ThreadLocal类中createmap函数内初始化的。每个线程都有一个这样的threadLocals引用的ThreadLocalMap，以ThreadLocal和ThreadLocal对象声明的变量类型作为参数。这样，我们所使用的ThreadLocal变量的实际数据，通过get函数取值的时候，就是通过取出Thread中threadLocals引用的map，然后从这个map中根据当前threadLocal作为参数，取出数据。下面是get方法的源码:

    public T get() {
        Thread t = Thread.currentThread();
        //获取当前线程的ThreadLocal.ThreadLocalMap threadLocals 实例对象
        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 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);
    }
    
    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
        Entry[] tab = table;
        int len = tab.length;

        while (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == key)
                return e;
            if (k == null)
                expungeStaleEntry(i);
            else
                i = nextIndex(i, len); // 获取下标
            e = tab[i];
        }
        return null;
    }
    /**
      * 获取initialValue初始化的值，并将初始化的值存储到数组中去
     * @return
     */
    private T setInitialValue() {
        // 调用初始化方法，可以在创建ThreadLocal实例的时候重写该方法
        T value = initialValue(); 
        Thread t = Thread.currentThread();
        // 获取当前线程成员变量 ThreadLocal.ThreadLocalMap threadLocals 的实例对象;
        ThreadLocalMap map = getMap(t); 
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value); // 创建 ThreadLocal.ThreadLocalMap threadLocals 实例对象
        return value;
    }

参考：http://www.importnew.com/20963.html