分析ThreadLocal的实现原理

ThreadLocal是开发中常会使用的一个工具，从类的名字就可以看出，它为线程提供本地变量，即：每个线程私有的数据。下面直接进入源码。
1、使用方法：

// Entity 存放线程要保存的信息
ThreadLocal<Entity> threadLocal = new ThreadLocal<Entity>();
//为线程设置私有数据
threadLocal.set(new Entity());
//拿出线程私有数据
threadLocal.get();

2、为线程设置私有数据：
①ThreadLocal的set()方法

  public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        //该线程的threadLocals已经初始化过，则调用ThreadLocalMap的set()方法，将数据push进来，否则调用createMap()函数初始化该变量
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
 ThreadLocalMap getMap(Thread t) {
 		//返回该线程的threadLocals变量
        return t.threadLocals;
    }
    
 void createMap(Thread t, T firstValue) {
 		//初始化该线程的threadLocals变量
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

 public class Thread implements Runnable {
 	//每一个线程会有唯一的一个ThreadLocalMap类型变量，用来保存该线程所有的私有数据
 	ThreadLocal.ThreadLocalMap threadLocals = null;
 }

②ThreadLocalMap的set()方法，从上面知道每一个线程有个ThreadLocalMap的实例，用来保存该线程的私有数据(一个线程可能会存很多不同类型的私有数据)。

//ThreadLocalMap 构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
			//数据是保存在一个数组里面的，初始长度为16
            table = new Entry[INITIAL_CAPACITY];
            //计算数据放在数组的哪个位置，是根据ThreadLocal 的threadLocalHashCode值来计算的
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            //以ThreadLocal实例为key，放入实际的数据
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
        
//Entry类实际存储着数据，继承 WeakReference       
static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                //保存放进来的线程私有数据
                value = v;
            }
        }

//ThreadLocalMap set方法
private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            //计算数据放入的位置
            int i = key.threadLocalHashCode & (len-1);
			//检测hash冲突，如果该位置已经放入了一个数据(e!=null)，则线性地向后查找第一个合适的位置
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                 //Entry 继承自WeakReference，所以用get()方法，可以直接拿到需要的key(ThreadLocal的实例)
                ThreadLocal<?> k = e.get();
				//找到一个位置，k和当前要插入的key值相同，更新该位置的数据
                if (k == key) {
                    e.value = value;
                    return;
                }
				//找到一个位置已经有数据，但是key为null，则替换掉废弃的key
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
			//将key-value存储到Entry中，放在数组的i位置
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //判断是否需要扩展数组，这里是长度大于数组长度的2/3时扩展数组
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

以上就将某个数据保存到线程私有数据中了，总结一下：Thread中有个ThreadLocalMap实例，ThreadLocalMap中有个数组：Entry[] table；，Entry中实际保存了数据value。也就是说一个线程可以有n多个私有数据，存放在ThreadLocalMap中，每一个私有数据对应一个ThreadLocal实例和一个Entry实例。

3、取出数据：
①ThreadLocal的get()方法：

    public T get() {
        Thread t = Thread.currentThread();
        //还是首先要拿到ThreadLocalMap实例
        ThreadLocalMap map = getMap(t);
        if (map != null) {
        	//以自己为key，从map中取出实际保存的数据，上面说过：数据是以ThreadLocal为key，实际数据为value保存到Entry对象中的
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

①ThreadLocalMap的getEntry()方法：

 private Entry getEntry(ThreadLocal<?> key) {
 			//计算数组下标，和放入数据时一样
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            //当前位置有数据，且key和要需要的一致，说明该位置保存了要的数据
            if (e != null && e.get() == key)
                return e;
            else
            	//散列冲突，根据需要的key线性向后查找
                return getEntryAfterMiss(key, i, e);
        }

以上就是ThreadLocal保存线程私有数据的大致实现原理，了解这些，相信对以后使用ThreadLocal会有积极的帮助。