ThreadLocal

ThreadLocal

1、定义：

**java官方文档中的描述：**
	ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。

	我们可以得知 ThreadLocal 的作用是：提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。

ThreadLocal叫做线程变量(局部)，填充的数据只属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。这是一种空间换时间的方式，而Synchronized是一种时间换空间的方式

ThreadLocal变量定义： 线程本地变量。

作用域： 线程内部

生命周期： 伴随线程执行始终，线程结束，变量生命结束

共享性： 多个线程之间不共享

ThreadLocal解决了变量在同一个线程内部之间的传递。 ThreadLocal首先不是解决线程安全问题，最显而易见的原因是ThreadLocal内部保存的变量在多线程之间不共享。数据都不共享，谈何线程安全？ 当然了，如果ThreadLocal内部保存的变量本身就是一个多线程共享的数据，那么还是会有线程安全的问题的。

如果没有ThreadLocal，我们需要在同一个线程之内共享的数据大约只能通过方法传递了。这样可能会让代码显得杂乱。

总结:

1. 线程并发: 在多线程并发的场景下
2. 传递数据: 我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量
3. 线程隔离: 每个线程的变量都是独立的，不会互相影响

优缺点：

优点：

1. 传递数据 ： 保存每个线程绑定的数据，在需要的地方可以直接获取, 避免参数直接传递带来的代码耦合问题
2. 线程隔离 ： 各线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损

缺点：

1、不能父子线程之间传递。 即在子线程中无法访问在父线程中设置的本地线程变量。 后来为了解决这个问题，引入了一个新的类InheritableThreadLocal。

2、容易造成内存泄漏

2、ThreadLocal 方法

方法声明	描述
ThreadLocal()	创建ThreadLocal对象
public void set( T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量
protected T initialValue() { }	initialValue()是一个protected方法，一般是用来在使用时进行重写的，这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

1、get() 方法

 /**
     * 返回当前线程中保存ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量，
     * 则它会通过调用{@link #initialValue} 方法进行初始化值
     *
     * @return 返回当前线程对应此ThreadLocal的值
     */
    public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 如果此map存在
        if (map != null) {
            // 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 找到对应的存储实体 e 
            if (e != null) {
                @SuppressWarnings("unchecked")
                // 获取存储实体 e 对应的 value值
                // 即为我们想要的当前线程对应此ThreadLocal的值
                T result = (T)e.value;
                return result;
            }
        }
        // 如果map不存在，则证明此线程没有维护的ThreadLocalMap对象
        // 调用setInitialValue进行初始化
        return setInitialValue();
    }

    /**
     * set的变样实现，用于初始化值initialValue，
     * 用于代替防止用户重写set()方法
     *
     * @return the initial value 初始化后的值
     */
    private T setInitialValue() {
        // 调用initialValue获取初始化的值
        T value = initialValue();
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 如果此map存在
        if (map != null)
            // 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将此实体entry作为第一个值存放至ThreadLocalMap中
            createMap(t, value);
        // 返回设置的值value
        return value;
    }

    /**
     * 获取当前线程Thread对应维护的ThreadLocalMap 
     * 
     * @param  t the current thread 当前线程
     * @return the map 对应维护的ThreadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    /**
     *创建当前线程Thread对应维护的ThreadLocalMap 
     *
     * @param t 当前线程
     * @param firstValue 存放到map中第一个entry的值
     */
    void createMap(Thread t, T firstValue) {
        //这里的this是调用此方法的threadLocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

执行流程

A. 首先获取当前线程

B. 根据当前线程获取一个Map

C. 如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的value e，否则转到E

D. 如果e不为null，则返回e.value，否则转到E

E. Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

总结:

​ 先获取当前线程的 ThreadLocalMap 变量，如果存在则返回值，不存在则创建并返回初始值。

2、set()方法

  	/**
     * 设置当前线程对应的ThreadLocal的值
     *
     * @param value 将要保存在当前线程对应的ThreadLocal的值
     */
    public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
    }

	 /**
     * 获取当前线程Thread对应维护的ThreadLocalMap 
     * 
     * @param  t the current thread 当前线程
     * @return the map 对应维护的ThreadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

	/**
     *创建当前线程Thread对应维护的ThreadLocalMap 
     *
     * @param t 当前线程
     * @param firstValue 存放到map中第一个entry的值
     */
	void createMap(Thread t, T firstValue) {
        //这里的this是调用此方法的threadLocal
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

执行流程

A. 首先获取当前线程，并根据当前线程获取一个Map

B. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）

C. 如果Map为空，则给该线程创建 Map，并设置初始值

3、remove()方法

 	/**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }

执行流程

A. 首先获取当前线程，并根据当前线程获取一个Map

B. 如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

4、initialValue方法

/**
  * 返回当前线程对应的ThreadLocal的初始值

  * 此方法的第一次调用发生在，当线程通过{@link #get}方法访问此线程的ThreadLocal值时
  * 除非线程先调用了 {@link #set}方法，在这种情况下，
  * {@code initialValue} 才不会被这个线程调用。
  * 通常情况下，每个线程最多调用一次这个方法。
  *
  * <p>这个方法仅仅简单的返回null {@code null};
  * 如果程序员想ThreadLocal线程局部变量有一个除null以外的初始值，
  * 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
  * 通常, 可以通过匿名内部类的方式实现
  *
  * @return 当前ThreadLocal的初始值
  */
protected T initialValue() {
    return null;
}

此方法的作用：返回该线程局部变量的初始值

（1） 这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。

（2）这个方法缺省实现直接返回一个null。

（3）如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

3、ThreadLocal核心结构

早期设计：

每个ThreadLocal类都创建一个Map，然后用线程的ID threadID作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法

JDK8之后设计：

JDK8 ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap哈希表，这个哈希表的key是ThreadLocal实例本身，value才是真正要存储的值Object。

（1） 每个Thread线程内部都有一个Map (ThreadLocalMap)

（2） Map里面存储ThreadLocal对象（key）和线程的变量副本（value）

（3）Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。

（4）对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

优点：

1） 这样设计之后每个Map存储的Entry数量就会变少，因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。（并不是每个线程都需要创建ThreadLocal，看自己需求）

2） 当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

4、ThreadLocalMap

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也独立实现。

和HashMap的最大的不同在于，ThreadLocalMap结构非常简单，没有next引用，也就是说ThreadLocalMap中解决Hash冲突的方式并非链表的方式，而是采用线性探测的方式。

线性探测

1.基本机构

1.成员变量

    /**
     * 初始容量 —— 必须是2的整次幂
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * 存放数据的table，Entry类的定义在下面分析
     * 同样，数组长度必须是2的整次幂。
     */
    private Entry[] table;

    /**
     * 数组里面entrys的个数，可以用于判断table当前使用量是否超过阈值。
     */
    private int size = 0;

    /**
     * 进行扩容的阈值，表使用量大于它的时候进行扩容。
     */
    private int threshold; // Default to 0
    

简单说明：

​ 跟HashMap类似，INITIAL_CAPACITY代表这个Map的初始容量；table 是一个Entry 类型的数组，用于存储数据；size 代表表中的存储数目； threshold 代表需要扩容时对应 size 的阈值。

2.存储结构 - Entry

在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。但是Entry中key只能是ThreadLocal对象，这点被Entry的构造方法已经限定死了。

/*
 * Entry继承WeakReference(**弱引用**)，并且用ThreadLocal作为key.
 * 如果key为null(entry.get() == null)，意味着key不再被引用，
 * 因此这时候entry也可以从table中清除。
 */
static class Entry extends WeakReference<ThreadLocal> {
    /** 与此 ThreadLocal 绑定的变量 */
    Object value;

    Entry(ThreadLocal k, Object v) {
        // ThreadLocal为弱引用
        super(k);
        value = v;
    }
}

注意： Entry继承自WeakReference（弱引用，生命周期只能存活到下次GC前），但只有Key是弱引用类型的，Value并非弱引用。

混淆点:

​ 使用ThreadLocal的过程中会发现有内存泄漏的情况发生，这个内存泄漏跟Entry中使用了弱引用的key是**没有关系**的。

由于ThreadLocalMap的key是弱引用，而Value是强引用。这就导致了一个问题，ThreadLocal在没有外部对象强引用时，发生GC时弱引用Key会被回收，而Value不会回收。

当线程没有结束，但是ThreadLocal已经被回收，则可能导致线程中存在ThreadLocalMap<null, Object>的键值对，造成内存泄露。（ThreadLocal被回收，ThreadLocal关联的线程共享变量还存在）导致内存泄漏

2.内存泄漏与弱引用

内存泄漏：

内存溢出 (Memory overflow)：

​ 没有足够的内存提供申请者使用。 内存泄漏 （Memory leak）：

​ 是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放,造成系统内存的浪费,导致程序运行速度减慢甚至系统崩溃等严重后果。I内存泄漏的堆积终将导致内存溢出。

弱引用：

Java中的引用有4种类型: 强、软、弱、虚。当前这个问题主要涉及到强引用和弱引用:

强引用（“Strong” Reference）: 就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾回收器就不会回收这种对象。

弱引用（WeakReference）: 垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

Java 关于强引用，软引用，弱引用和虚引用的区别与用法

jvm就像一个国家，gc就是城管，强引用就是当地人，软引用就是移民的人，弱引用就是黑户口，哪天城管逮到就遣走，虚引用就是一个带病的黑户口，指不定哪天自己就挂了

1.如果key使用强引用

假设ThreadLocalMap中的key使用了强引用，那么会出现内存泄漏吗？

此时ThreadLocal的内存图（实线表示强引用）如下：

`假设在业务代码中使用完ThreadLocal ，threadLocal Ref（当前threadLocal）被回收了。
`但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。
`在没有手动删除（调用remove()方法）这个Entry以及CurrentThread（当前线程）依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。

 也就是说，ThreadLocalMap中的key使用了强引用， 是无法完全避免内存泄漏的。

2.如果key使用弱引用

那么ThreadLocalMap中的key使用了弱引用，会出现内存泄漏吗？

此时ThreadLocal的内存图（实线表示强引用，虚线表示弱引用）如下：

`同样假设在业务代码中使用完ThreadLocal ，threadLocal Ref（当前threadLocal）被回收了。
`由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。
`但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收， 而这块value永远不会被访问到了，导致value内存泄漏。

也就是说，ThreadLocalMap中的key使用了弱引用， 也有可能内存泄漏。

3.ThreadLocal出现内存泄漏的真实原因

比较以上两种情况，我们就会发现，内存泄漏的发生跟ThreadLocalMap中的key是否使用弱引用是没有关系的。那么内存泄漏的的真正原因是什么呢？

在以上两种内存泄漏的情况中，都有两个前提：

1. 没有手动删除这个Entry
2. CurrentThread依然运行

第一点很好理解，只要在使用完ThreadLocal，调用其remove()方法删除对应的Entry，就能避免内存泄漏。

第二点稍微复杂一点， 由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期跟Thread一样长。那么在使用完ThreadLocal之后，如果当前Thread也随之执行结束，ThreadLocalMap自然也会被gc回收，从根源上避免了内存泄漏。

ThreadLocal内存泄漏的根源是：

​ 由于ThreadLocalMap的生命周期跟Thread一样长（每个Thread维护一个ThreadLocalMap哈希表），如果没有手动删除对应key就会导致内存泄漏。

4.为什么使用弱引用

通过上面分析： 无论ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

要避免内存泄漏有两种方式：

1. 使用完ThreadLocal，调用其remove方法删除对应的Entry
2. 使用完ThreadLocal，当前Thread也随之运行结束

相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的。

​ 也就是说，只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？

​ 事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。

这就意味着使用完ThreadLocal，CurrentThread（当前线程）依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除（直到下一次调用set,get,remove中的任一方法，才会被清除，本身并不会被GC），从而避免内存泄漏。

5.Hash冲突的解决

hash冲突的解决是Map中的一个重要内容。我们以hash冲突的解决为线索，来研究一下ThreadLocalMap的核心源码。

（1） 首先从ThreadLocal的set() 方法入手

  public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocal.ThreadLocalMap map = getMap(t);
        if (map != null)
            //调用了ThreadLocalMap的set方法
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    ThreadLocal.ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        	//调用了ThreadLocalMap的构造方法
        t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
    }

这个方法上文（2.2）有分析过, 其作用是设置当前线程绑定的局部变量 :

1. 首先获取当前线程，并根据当前线程获取一个Map
2. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）

(这里调用了ThreadLocalMap的set方法)

3. 如果Map为空，则给该线程创建 Map，并设置初始值

(这里调用了ThreadLocalMap的构造方法)

这段代码有两个地方分别涉及到ThreadLocalMap的两个方法, 我们接着分析这两个方法。

（2）构造方法ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

 /*
  * firstKey : 本ThreadLocal实例(this)
  * firstValue ： 要保存的线程本地变量
  */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化table
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        //计算索引(重点代码）
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //设置值
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        //设置阈值
        setThreshold(INITIAL_CAPACITY);
    }

 `构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。

重点分析： int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)。

1. 关于firstKey.threadLocalHashCode：

 	private final int threadLocalHashCode = nextHashCode();
    
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
	
	//AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
    private static AtomicInteger nextHashCode =  new AtomicInteger();
     /**特殊的hash值
     连续生成的哈希码之间的差异 - 将隐式顺序线程本地 ID 转换为接近最优分布的乘法哈希值，用于 2 次方大小的表。
     */
    private static final int HASH_INCREMENT = 0x61c88647;

这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免hash冲突。

原子类（java.util.concurrent.atomic包下）CAS机制

CAS的全成是： Compare And Swap(比较再交换); 是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。CAS可以将read-modify-write转换为原子操作，这个原子操作直接由处理器保证。(经典实现：ConcurrentHashMap)

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

2.关于& (INITIAL_CAPACITY - 1)

计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证在索引不越界的前提下，使得hash发生冲突的次数减小。

（3） ThreadLocalMap中的set方法

private void set(ThreadLocal<?> key, Object value) {
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
        //计算索引(重点代码，上面已分析）
        int i = key.threadLocalHashCode & (len-1);
        /**
         * 使用线性探测法查找元素（重点代码）
         */
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
            if (k == key) {
                e.value = value;
                return;
            }
            // key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
           // 当前数组中的 Entry 是一个陈旧（stale）的元素
            if (k == null) {
                //用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
                replaceStaleEntry(key, value, i);
                return;
            }
        }
    
    	//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
            tab[i] = new Entry(key, value);
            int sz = ++size;
            /**
             * cleanSomeSlots用于清除那些e.get()==null的元素，
             * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
             * 如果没有清除任何entry,并且当前使用量达到了threshold [负载因子所定义(长度的2/3)]，那么进行				 
             * rehash（执行一次全表的扫描清理工作）
             */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                /**
                * 重新包装和/或重新调整表格的大小。首先扫描整个表，删除陈旧的条目。					  
                * 如果这不能充分缩小表格的大小，请将表格大小加倍。
                */
                rehash();
}

 /**
     * 获取环形数组的下一个索引
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

代码执行流程：

1. 先还是根据key计算出索引 i，然后查找i位置上的Entry
2. 若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值,
3. 若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry,（用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏）
4. 不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。
5. 最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz 是否>= thresgold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理。

重点分析 ： ThreadLocalMap使用线性探测法来解决哈希冲突的。

该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。

​ 举个例子，假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，这个时候将14加1得到15，取table[15]进行判断，这个时候如果还是冲突会回到0，取table[0],以此类推，直到可以插入。

按照上面的描述，可以把Entry[] table看成一个环形数组。

5、ThreadLocal类与synchronized关键字

public class TestThreadLocal {
    private String content;
    // 创建ThreadLocal
    ThreadLocal<String> stringLocal = new ThreadLocal<String>();

    public String getContent() {
        return content;
        // 获取当前线程变量
		  //return stringLocal.get();
    }

    public void setContent(String content) {
        this.content = content;
        // 线程绑定变量
		//stringLocal.set(content);
    }

    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (TestThreadLocal.class) {
                        testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
                        System.out.println("-----------------------");
                        System.out.println(Thread.currentThread().getName() + "---->" + testThreadLocal.getContent());
                    }
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

区别：

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

	synchronized	ThreadLocal
原理	同步机制采用’以时间换空间’的方式, 只提供了一份变量,让不同的线程排队访问	ThreadLocal采用’以空间换时间’的方式, 为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重点	多个线程之间访问资源的同步性	多线程中让每个线程之间的数据相互隔离

总结：

使用ThreadLocal更为合适,因为这样可以使程序拥有更高的并发性。

6、Demo1

public class TestThreadLocal {
    private String content;
    // 创建ThreadLocal
    ThreadLocal<String> stringLocal = new ThreadLocal<String>();

    public String getContent() {
        return content;
        // 获取当前线程变量
//        return stringLocal.get();
    }

    public void setContent(String content) {
        this.content = content;
        // 线程绑定变量
//        stringLocal.set(content);
    }

    public static void main(String[] args) {
        TestThreadLocal testThreadLocal = new TestThreadLocal();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
                    System.out.println("-----------------------");
                    System.out.println(Thread.currentThread().getName() + "---->" + testThreadLocal.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }

}

7、问题

1、内存泄漏和ThreadLocalMap种Key的弱引用有关系嘛？内存泄漏真正原因是什么？

没有关系。

**真正原因：**由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应的key就会导致内存泄漏

2、如何避免泄漏

1、使用完线程共享变量后，显示调用ThreadLocalMap.remove方法清除线程共享变量； 既然Key是弱引用，那么我们要做的事，就是在调用ThreadLocal的get()、set()方法时完成后再调用remove方法，将Entry节点和Map的引用关系移除，这样整个Entry对象在GC Roots分析后就变成不可达了，下次GC的时候就可以被回收。

2、JDK建议ThreadLocal定义为private static，避免重复创建实例，这样ThreadLocal的弱引用问题则不存在了。（ThreadLocal类的目的是为每个线程单独维护一个变量的值，避免线程间对同一变量的竞争访问，适用于一个变量在每个线程中需要有自己独立的值的场合。）

ThreadLocal变量通常设置为static的原因

ThreadLocal就跟加锁完要解锁一样，用完就需要清理。

3、那么为什么key要用弱引用呢?

事实上，在ThreadLocalMap中的set/getEntry方法中,会对key为null (也即是ThreadLocal为null )进行判断,如果为nul的话,那么是会对value置为null的。

这就意味着使用完ThreadLocal , CurrentThread依然运行的前提下,就算忘记调用remove方法,弱引用比强引用可以多一层保障:弱引用的ThreadLocal会被回收,对应的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除,从而避免内存泄漏。

参考

1. 黑马程序员Java基础教程由浅入深全面解析threadlocal
2. 由浅入深，全面解析ThreadLocal