ThreadLocal 分析

这篇文章好

https://www.cnblogs.com/dolphin0520/p/3920407.html

ThreadLocal特点与作用

处理多线程情况下的线程安全问题。

ThreadLocal原理

每一个Thread 内部独立维护着一个 ThreadLocal.ThreadLocalMap
这个Map 的 Key 是 ThreadLocal 对象的地址 也就是不同的ThreadLocal 对象 对应不同的key

代码

public class ThreadLocal {

    private final int threadLocalHashCode = nextHashCode();
    private static AtomicInteger nextHashCode =   new AtomicInteger();
    private static final int HASH_INCREMENT = 0x61c88647;
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

  //初始化值方法  重写  第一次Get值的时候 若是没有Set过值 就执行这个初始化方法
  //见get方法的 setInitialValue()
    protected T initialValue() {
        return null;
    }
  //大部分同set
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //从ThreadLocal取值 
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        //取不到值就进行初始化
        return setInitialValue();
    }
 
  //set
    public void set(T value) {
        //获取当前执行的线程
        Thread t = Thread.currentThread();
       //获取这个线程维护的ThreadLocalMap
        ThreadLocalMap map = getMap(t);//return t.threadLocals
       //没有就创建个
        if (map != null)
            //key 是this 也就是当前ThreadLocal对象
            map.set(this, value);
        else
            createMap(t, value);
    }


   /************************传说中的ThreadLocalMap结构 就一数组***********************/
    static class ThreadLocalMap {
       //存取值的最基本单位
        static class Entry extends WeakReference> {
            /** The value associated with this ThreadLocal. */
            Object value;

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


        private static final int INITIAL_CAPACITY = 16;

        //嘻嘻 最终的数据就是这个table数组
        private Entry[] table;

    
        private int size = 0;

   
        private int threshold; // Default to 0

   
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

    
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }


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

        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);
        }
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal