ThreadLocal原理

Thread类里维护了一个ThreadLocalMap,这个map的key是ThreadLocal，所有说一个Thread里可以有多个ThreadLocal

ThreadLocal作用：

提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度
常用方法：
- ThreadLocal（）:构造方法
- public void set（T value）：给当前线程绑定局部变量
- public T get（）：取出当前线程绑定的局部变量
- public void remove（）：删除当前线程绑定的局部变量
ThreadLocal与synchronized的区别：
- ThreadLocal相当于是空间换时间，为每一个线程提供一份变量的副本，从而实现同时访问而相互不干扰
- synchronized则是时间换空间，只有一份变量，让不同线程排队访问
- 时间带来的是性能的损耗，并发性能的降低（一个一个等着取东西）
ThreadLocal内部设计：
- 每个Thread内部都有一个ThreadLocalMap，这个map由ThreadLocal来维护，由ThreadLocal向map中设置和获取线程的变量值
- Map里面存储ThreadLocal对象（key），线程的变量副本（value）
- 对于不同的线程的副本值形成了隔离，互不干扰

看源码：

set（）：

public void set(T value) {
    //通过当前线程来取ThreadLocalMap
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
    //判断map是否存在
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    
    }

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;//这个threadLocals就是维护的ThreadLocalMap
    }

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

get（）：

public T get() {
       //通过当前线程来取ThreadLocalMap
        Thread t = Thread.currentThread();
        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;
            }
        }
    //没有map 或 有map没取到value
        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);
        }
    
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
    
        return value;
    }

protected T initialValue() {
        return null;
    }

remove（）：

 public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null) {
             m.remove(this);
         }
     }
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.refersTo(key)) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

ThreadLocalMap(是Thread的一个属性）：

key是当前ThreadLoal对象的引用

value是Entry：

 static class Entry extends WeakReference<ThreadLocal<?>> {
         //Entry继承了弱引用，本身也是个键值对
            Object value;

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

弱引用相关：
- 内存溢出：就是内存不够用了
- 内存泄漏：已分配出去的内存，因为某些原因无法GC了，那就GG了
- 弱引用：垃圾回收器一旦发现具有弱引用的对象，不管当前内存空间足够与否，都会进行GC
- 使用完ThreadLoacl，ThreadLoacl ref被回收，key又是弱引用，所以ThreadLoacl可以被GC
- 但是如果没有手动删除这个Entry以及CurrentThread还在运行的前提下，存在强引用链Thread Ref -> current thread-> ThreadLoaclMap -> Entry -> value，value不会被GC，且此时ThreadLoacl已经被GC，key为null，意味着value无法被访问，value这块内存就是泄露了
- 内存泄漏的原因是：
  1. 使用完删除Entry
  2. CurrentThread依然运行
- 内存泄漏的根源：
  
  ThreadLocalMap是Thread的一个属性，所以两者的生命周期一样长，如果没有手动删除Entry就会内存泄漏
- 但是但是：
  - ThreadLocalMap内部的set/get/remove方法中，会对key（ThreadLocal）为null的情况进行判断，如果key为null，会对value赋值为null，这意味着就算你使用完没删除Entry，在你下一次调用set/get/remove方法时，会清楚value，避免内存泄漏，这是一种保障，也是使用弱引用的优势
Hash冲突：

ThreadLocalMap使用线性探测法来解决Hash冲突：

一次探测下一个地址，直到空的地址插入，若整个空间都找不到空余的地址，就产生溢出

可以把Entry[ ] table看成是一个环形数组

ThreadLocal原理

ThreadLocal原理

ThreadLocal作用：

常用方法：

ThreadLocal与synchronized的区别：

ThreadLocal内部设计：

每个Thread内部都有一个ThreadLocalMap，这个map由ThreadLocal来维护，由ThreadLocal向map中设置和获取线程的变量值

看源码：

弱引用相关：

但是但是：

Hash冲突：