ThreadLocal的作用

此内容主要通过黑马程序员的ThreadLocal学习所做的笔记

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

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

线程解读：

• 定义： 线程是程序执行流的最小单元。在多线程编程中，一个程序可以同时执行多个线程，每个线程都有自己的执行路径，但共享相同的资源。

• 作用： 多线程编程可以提高程序的并发性，允许程序同时执行多个任务。在多核处理器上，多线程可以更充分地利用硬件资源。

函数解读：

• 定义： 函数是一段可重用的代码块，它接受输入参数、执行一系列操作，并返回结果。

• 作用： 函数提供了一种将代码模块化、可重用的方式。它可以接受输入，执行特定任务，然后返回结果，有助于提高代码的可读性和可维护性。

组件解读：

• 定义： 组件是一个软件系统中的独立单元，通常由多个相关的函数、类、模块等组成，用于完成特定的任务或提供特定的功能。

• 作用： 组件化是一种软件设计方法，通过将系统划分为独立的组件，可以提高系统的可维护性、可扩展性和重用性。每个组件负责特定的功能，与其他组件解耦。

ThreadLocal基本使用

常用的方法：

方法声明	描述
TheadLocal()	创建ThreadLocal对象
public void set(T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

案例：

/* *
 *  需求：线程隔离
 *		在多线程并发的场景下，每个线程中的变量都是相互独立的。
 *		线程A：设置（变量1）		获取（变量1）
 *		线程B：设置（变量2）		获取（变量2）
 *		
 * 		ThreadLocal：
 *			1.set():将变量绑定到当前线程中
 *			2.get():获取当前线程绑定的变量
 * */

public class MyDemo01{
    ThreadLocal <String> t1 = new ThreadLocal<>();
    
    //变量
    private String content;
    
    private String getContent(){
  //      return content
        String s = t1.get();
        return s;
    }
    
    private void setContent(String content){
  //      this.content = content;
        //变量content绑定到当前线程
        t1.set(content);
    }
    
    public static void main(String[] args){
        MyDemo01 demo = new MyDemo01();
        for(int i = 0 ; i < 5 ; i++){
            Thread thread = new Thread(new Runnable(){
                @Override
                public void run(){
                    /*
                    	每个线程：存一个变量，过一会取出这个变量
                    */
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("----------------------");
                    System.out.println(Thread.currrentThread().getName() + "---->" + demo.getContent());
                }
            });
            thread.setName("线程" + i);//线程0~4
            thread.start();
        }
    }
}

ThreadLocal类与synchronized关键字

synchronized同步方式

/* *
 *  需求：线程隔离
 *		在多线程并发的场景下，每个线程中的变量都是相互独立的。
 *		线程A：设置（变量1）		获取（变量1）
 *		线程B：设置（变量2）		获取（变量2）
 *		
 * */

public class MyDemo01{
    
    //变量
    private String content;
    
    private String getContent(){
        return content
    }
    
    private void setContent(String content){
        this.content = content;
    }
    
    public static void main(String[] args){
        MyDemo01 demo = new MyDemo01();
        for(int i = 0 ; i < 5 ; i++){
            Thread thread = new Thread(new Runnable(){
                @Override
                public void run(){
                    /*
                    	每个线程：存一个变量，过一会取出这个变量
                    */
					synchronized(MyDemo02.class){
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("----------------------");
                    System.out.println(Thread.currrentThread().getName() + "---->" + demo.getContent());
                    }
                }
            });
            thread.setName("线程" + i);//线程0~4
            thread.start();
        }
    }
}

synchronized与TheadLocal的区别

虽然ThreadLocal模式与synchronized关键字都用于处理多线程并发访问变量的问题，不过两者处理问题的角度和思虑不同。

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

总结：在刚刚的案例中，虽然使用ThreadLocal和synchronized都能解决问题，但是使用ThreadLocal更为合适，因为这样可以使程序拥有更高的并发性。

转账案例

事务的使用注意点：

1.service层和dao层的连接对象保持一致

2.每个线程的connection对象必须前后一致，线程隔离。

常规的解决方案

1.传参：将service层的connection对象直接传递到dao层。

2.加锁。

常规方案

1.方法添加一个参数conn

2.不能从连接池中获取连接，直接使用参数conn

3.注意：dao层不能释放连接

常规解决方案的弊端

1.提高代码耦合度

2.降低程序性能（排队一个一个执行）

用ThreadLocal的解决方案

获取连接：

原本：直接从连接池中获取连接

现在：1.直接获取当前线程绑定的连接对象

2.如果连接对象是空的

2.1再去连接池中获取连接。

2.2将此连接对象跟当前线程进行绑定。

在有静态的情况下，所有相连的公式代码都需要静态static。

ThreadLocal方案的好处

ThreadLocal方案有两个突出的优势：

1.传递数据：保存每个线程绑定的数据，在需要的地方可以直接获取，避免参数直接传递带来的代码耦合的问题。

2.线程隔离：线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损失。

ThreadLocal的内部结构

在JDK8中ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value才是真正要存储的值Object。具体的过程是这样的：

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

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

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

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

JDK8的设计方案两个好处;

1.每个Map存储的Entry数量变少（在代码中用ThreadLocal的比Thread的多）

2.当Thread销毁的时候，ThreadLocalMap也会随之销毁，减少内存的使用。

ThreadLocal的核心代码源码

除了构造方法之外，ThreadLocal对外暴露的方法有以下4种：

方法声明	描述
TheadLocal()	创建ThreadLocal对象
public void set(T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

set方法源码

/*
 * 设置当前线程对应的ThreadLocal的值
 */
public void set(T value) {
    //获取当前的线程对象
    Thread t = Thread.currentThread();
    //获取次线程对象种维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    //判断该map是否存在
    if (map != null)
        //如果存在就调用该map去设置此实体Entry
        map.set(this, value);
    else
        //如果线程Thread不存在ThreadLocalMap对象
        //就调用creatMap进行ThreadLocalMap对象初始化
        //并将t(当前线程)和vlaue(t对应的值)作作第一个entry存放至ThreadLocalMap中
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
	//t就是当前线程，threadLocal就是当前线程对应维护的ThreadLocal
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
     //这个this是调用此方法的threadLocal，firstValue就是要插入的值
     t.threadLocals = new ThreadLocalMap(this, firstValue);
}

通过上面代码我们得知，set方法主要做了

1.先获取ThreadLocalMap通过当前线程

2.如果获取结果为null，就给该线程创建map，并设置好初始化参数，

3.如果不为null，就将参数设置到Map数组中

---

代码执行流程：

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

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

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

get方法

public T get() {
    //获取当前线程对象
    Thread t = Thread.currentThread();
    //获取此线程中维护的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
	//判断是否存在
    if (map != null) {
        //以当前的threadLocal为key调用geentry获取对应存储的实例
        ThreadLocalMap.Entry e = map.getEntry(this);
        //查看实例不为null就返回value
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    /*
     *	如果执行初始化就有2种可能
     *		第一种情况：map不存在，表示此线程没有维护的ThreadLocalMap对象
     *		第二种情况: map存在，但是没有与当前ThreadLocal关联的Entry(实体)
     *		此方法的作用就是返回当前ThreadLocal的初始值
     */
    return setInitialValue();
}

  private T setInitialValue() {
      	//
        T value = initialValue();  
       Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //设置实体
            map.set(this, value);
        else
            //如果map为null 就创建map对象
            createMap(t, value);
        return value;
 }

通过上面代码我们可以知道：

1.首先获取当前线程，根据线程获取一个map

2.如果获取的map不为null，就在Map种以ThreadLocal的引用作为key来在Map中获取对应的Entry，如果获取到了就返回它的值。如果没有获取到map,就通过initialVlue函数获取初始化value，然后用 threadLocal的引用和val作为key和value创建一个新的map

总结一句话：先获取线程ThreadLocalMap变量，如果存在就返回值，不存在就创建并返回初始值

---

代码执行流程：

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

B.如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entrye，否则转到D

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

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

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

remove方法

public void remove() {
    //获取当前线程对象中维护的ThreadLocalMap对象
    ThreadLocalMap m = getMap(Thread.currentThread());
    //如果存在
    if (m != null)
        //就调用map.remove进行删除  通过ThreadLocal的引用为key来删除
        m.remove(this);
}

通过上面代码我们可以得知，

1.首先根据当前线程获取ThreadLocalMap

2.如果获取的Map不为空就移除当前ThreadLocal的引用为key对应的实体就好了

initialValue方法

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

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

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

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

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

ThreadLocalMap源码分析

在ThreadLocal方法的时候，ThreadLocal实际上是围绕的ThreadLocalMap进行展开的。

基础结构

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

（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

/**
 *	Entry继承weakReference，并且用ThreadLocal作为key，
 *	如果key为null（entry.get() == null）,意味着key不再被引用，
 *	因此这时候entry也可以从table中清除
 **/
static class Entry extends WeakReference<ThreadLocal<?>>{
    /** The value associated with this ThreadLocal.*/
    Object value;
    
    Entry(ThreadLocal<?> k , Object v){
        super(k);
        value = v;
    }
}

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

另外，Entry继承WeakReference，也就是Key（ThreadLocal）是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

弱引用和内存泄露

（1）内存泄漏相关概念

• Memory overflow：内存溢出，没有足够的内存提供申请者使用。

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

（2）弱引用相关概念

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

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

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

（3）如果key使用强引用

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

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

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

1.假设在业务代码中使用完ThreadLocal，threadLocal Ref被回收了。

2.但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。

3.在没有动手删除这个Entry以及CurrentThread依然运行的前提下，始终有强引用链threadRef -> currentThread -> entry , Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。

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

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

1.同样假设在业务代码中使用完ThreadLocal，threadLocal Ref被回收了。

2.由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例，所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。

3.但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，存在有强引链threadRef -> currentThread -> threadLocalMap -> entry -> value , value不会被回收，而这块value永远不会被访问到了，导致value内存泄漏。

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

出现泄漏的真实原因

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

那么内存泄漏的的真正原因是什么？

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

1.没有手动删除这个Entry。

2.CurrentThread依然在运行。

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

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

综上，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏。

（1）为什么使用弱引用

根据刚才的分析，我们知道了：无论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中的任一方法的时候会被清除，从而避免内存泄漏。

ThreadLocal中hash冲突的解决

/*
 * 设置当前线程对应的ThreadLocal的值
 */
public void set(T value) {
    //获取当前的线程对象
    Thread t = Thread.currentThread();
    //获取次线程对象种维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    //判断该map是否存在
    if (map != null)
        //如果存在就调用该map去设置此实体Entry
        map.set(this, value);
    else
        //如果线程Thread不存在ThreadLocalMap对象
        //就调用creatMap进行ThreadLocalMap对象初始化
        //并将t(当前线程)和vlaue(t对应的值)作作第一个entry存放至ThreadLocalMap中
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
	//t就是当前线程，threadLocal就是当前线程对应维护的ThreadLocal
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
     //这个this是调用此方法的threadLocal，firstValue就是要插入的值
     t.threadLocals = new ThreadLocalMap(this, firstValue);
}

首先看一下ThreadLocalMap构造方法

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化table
    table = new Entry[INITIAL_CAPACITY];
    //计算索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //设置值
    table[i] = new Entry(firstKey, firstValue);
    //设置元素个数
    size = 1;
    //设置阈值
    setThreshold(INITIAL_CAPACITY);
}

当达到了当前数组容量的2/3就会进行扩容，扩容2倍

再来看下set(ThreadLocal<?> key, Object value)方法

private void set(ThreadLocal<?> key, Object value) {


    Entry[] tab = table;
    int len = tab.length;
    //指定下标计算
    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i];
         e != null;
         //nextIndex是获取环形数组的下一个节点
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
		//如果key值存在直接替换value
        if (k == key) {
            e.value = value;
            return;
        }
		
        //key为null，但是值不为null，说明之前的ThreadLocal对象已经被回收了
        //当前数组中的Entry是一个陈旧的元素
        if (k == null) {
            //用心的元素替换旧元素，这个方法做了不少的垃圾清理动作，防止内存泄漏
            replaceStaleEntry(key, value, i);
            return;
        }
    }
	//ThreadLocal对应的key不存在并且没有找到旧的元素，则在空元素的位置创建一个新的Entry
    tab[i] = new Entry(key, value);
    int sz = ++size;
    //cleanSomeSlots用于清理那些e.get（）为null的元素
	//如果没有清理任何entry，并且当前使用的量达到了阈值，那么久进行rehash(执行一次全表的扫描清理工作)
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

我们通过这些代码可以得出，添加方法就是

1.根据key计算出索引，然后查找i位置上的Entry

2.如果Entry已经存在，并且存在的key跟要传入的key一样，那么这时候就给这个key复制新的val值

3.如果entry存在，但是key为null，那么就调用replaceStaleEntry来更换这个key为null的Entry

4.不断循环检测，直到遇见为null的地方，这时候要是没有在循环过程中return，那么久在这个null的位置新建一个Entry然后并擦除数据，同时size++；

最后调用cleanSomeslots,清理Key为null的Entry，然后返回是否清理了Entry，接下来判断siez是否>=阈值达到了rehash条件，如果达到了就会调用rehash进行执行一次全表扫面清理。

重点分析;

ThreadLocalMap使用线性探测法来解决哈希冲突的。

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

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

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