ThreadLocal原理

ThreadLocal是常用的存储线程独有变量的,怎么实现的每个线程独有的，并且实现的线程间安全的呢，听说的内存泄漏是什么情况，有什么影响？

put

    @Test
    public void testThreadLocal(){
        ThreadLocal<String> stringThreadLocal = new ThreadLocal<>();
    	// 存入变量
        stringThreadLocal.set("test");
        // 获取
        stringThreadLocal.get();
        // 清除
        stringThreadLocal.remove();
    }
	// 设置方法
    public void set(T value) {
    	// 当前线程
        Thread t = Thread.currentThread();
    	// 获取map
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 存入变量，this为ThreadLocal
            map.set(this, value);
        } else {
            // map未初始化的时候创建一个，并把值放进去
            createMap(t, value);
        }
    }
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
// ThreadLocalMap的set方法
        private void set(ThreadLocal<?> key, Object value) {
        
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
        	// 需要存放的位置，这里是hash冲突的之后直接存到后面的位置
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                // 取到对对应的entry
                ThreadLocal<?> k = e.get();
            	// 如果相等，替换值
                if (k == key) {
                    e.value = value;
                    return;
                }
            	// 如果为null的，需要对应的处理，先不深追了，这里就是会处理key为null的
                // 这些是已经被回收的了，处理避免内存泄漏，不可能在被使用的值
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            // 超过一定大小，扩容
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }


// 创建
    void createMap(Thread t, T firstValue) {
        // 这里把创建的map赋值给了Thread的threadLocal变量
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
    	// 创建一个ThreadLocalMap，值直接放上去了
        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);
        }
// 这里的threadLocals是Thread类的一个成员变量
ThreadLocal.ThreadLocalMap threadLocals = null;

简单总结下put的过程，获取当前线程，然后找到线程的成员变量threadLocals，如果变量未初始化，就初始化一个map放进去，如果已经初始化过的，就直接key为ThreadLocal本身，value为存入的值，创建的map赋值给Thread的成员变量threadLocals，所以这里就能看出来为什么线程独有，线程安全，因为数据就是存储在线程里面，可以认为就是线程私有的，这应该也是ThreadLocal命名的来源，很形象，那么key为ThreadLocal本身，还不允许自定义key，那么只有当一个线程里面新建多个ThreadLocal对象，然后对其存入值的时候。，Thread里面的才会有多个值，如果只有一个ThreadLocal对象，那么不管多少线程来，每个线程里面的map也最多存一个数据。

get

    public T get() {
        Thread t = Thread.currentThread();
        // 获取map
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // map存在的时候就获取对应的entry没然后取值
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
	// 看下获取Entry的过程
        private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            // 对应的Entry是不是空
            if (e != null && e.get() == key)
                return e;
            else // 如果对应位置为null（被回收了），或者不等于key（hash冲突的时候）
                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// 不为null不想等的时候，hash冲突，找下一个
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }
// key为null的时候触发
        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
        	// 设置对应的value为null，帮助gc，回收用不到的数据
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) 
        	// 这里遍历下，如果一直entry不为null，一直遍历
                ThreadLocal<?> k = e.get();
            	//key为null就会处理，因为entry不为null，这里释放value引用
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    // 这里是判断下之前应该放的位置是不是有值
                    int h = k.threadLocalHashCode & (len - 1);
                    // 判断下标是不是应该在这里，还是因为hash冲突后移动到这里的
                    if (h != i) {
                        tab[i] = null;
                        // 这里因为不等，所以把对应的entry移动回正确的位置
                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

这里的get总结下，就是获取的之后遇到hash冲突就会去获取下一个（hash冲突的处理逻辑），然后下一个如果entry不为空，但是key为空，那就需要把对应的值处理掉，然后一直向下遍历，知道entry为空的时候，这里遍历到的值，就把他们送到正确的位置，也就是向前移动（因为空的值被处理掉了），这里Entry的key为什么为null，就是这里的Entry的结构设计了

        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

Entry继承了若引用，然后让key成为了若引用，也就是这里的ThreadLocal销毁之后，弱引用就可以回收了，比如ThreadLocal直接在成员方法里面new的，方法执行完了,栈里面引用的对象就可以被回收了，但是线程如果没销毁，这里面的threadLocals对应的map里面就存着对应存放的值，然后key对象也被回收了，就造成了key为null的Entry对象

remove

        private void remove(ThreadLocal<?> key) {
            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)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

这里找到对应的key然后移除，然后就看后面紧接着是不是有因为hash冲突后移的节点或者key为null的Entry节点进行处理。

总结

这里简单总结下ThreadLocal的数据是储存在每个线程里面的ThreadLocalMap里面为Thread的成员变量，所以是线程私有，线程安全的，hash冲突是通过向后移动进行解决的，所以在删除ENtry的时候，需要判断后面有没有需要移动的值，在每次put，get，remove的时候都会对key为null的Entry进行处理，也是为了处理内存泄漏，这样清除不会使用到的值，那什么情况下还是会内存泄漏呢，也就是当在new ThreadLocal对象，然后ThradLocal对象已经被回收了，但是数据还没remove的时候，这时候对应的数据不会再被获取到，但是还是会存在map里面，称之为内存泄漏，数据是跟随线程存在的，线程销毁就不存在对应的问题，如果同一个线程下次再来对应的方法，new 的是另一个ThreadLocal，获取的就是另一个对象了，只有当其hash冲突，会主动清理key为null的数据，如果ThreadLocal是同一个，那就会因为线程重用，获取到之前的数据，所以推荐的是用完之后remove掉，这样避免了内存泄漏，也避免获取到垃圾数据。
如果使用的同一个ThreadLocal就是只会获取到垃圾数据，就不泄漏了，因为还可以获取到数据，只不过不一定是自己想要的，这时候如果value所占内存不是特别大，那就只跟线程数有关系，不会造成特别大的影响，不过还是保持好习惯，随手remove掉吧