再次理解Threadlocal

左手的ㄟ右手 2022-10-12 00:44 115阅读 0赞

> 温故而知新，但要做笔记。

# 1.ThreadLocal 解决了什么问题 #

解决了两个问题：

1.  不同线程之间，变量隔离。
2.  同一个线程中，不同的方法之间变量共享。

# 2. ThreadLocal 的使用 #

ThreadLocal 的使用很简单，就三个方法：

public void set(T value) { } //将变量与当前线程绑定。（将变量存储到当前线程中）
    public T get() { } //从当前线程中拿出变量。
    public void remove() { } // 将变量与当前线程解绑。（从当前线程中移除变量）

demo 演示

public class MyDemo02 { 
      // 定义 ThreadLocal 变量，可以持有 String 类型。
      public static ThreadLocal<String> t1 = new ThreadLocal<>();
    
      public static void main(String[] args) { 
        VariableInThreadLocal();
      }
        
      private static void VariableInThreadLocal() { 
        for(int i=0;i<5;i++){ 
          Thread thread = new Thread(new Runnable() { 
            @Override
            public void run() { 
              write();
              System.out.println("-----"+ Thread.currentThread().getName() + "写---------");
              read();
            }
    
            public void write(){ 
              // 通过 t1 将数据绑定到 i 线程。
              t1.set(Thread.currentThread().getName()+ "的数据");
            }
    
            public void read(){ 
              // 通过 t1 将 i 线程中拿出数据。
              System.out.println(Thread.currentThread().getName() + " 拿到" + t1.get());
            }
    
          },"线程："+ i);
          thread.start();
        }
      }
    }

测试结果：

-----线程：0写---------
    -----线程：2写---------
    -----线程：1写---------
    -----线程：4写---------
    线程：1 拿到线程：1的数据
    线程：2 拿到线程：2的数据
    -----线程：3写---------
    线程：0 拿到线程：0的数据
    线程：3 拿到线程：3的数据
    线程：4 拿到线程：4的数据

5 个线程出现了并发，代码执行控制线程启动，哪个线程先拿到 CPU 的时间片，这个没法确定的。

但是即便如此，`t1` 作为纽带工具将变量和线程绑定，使每个线程通过 threadlocal 都能准确拿到之前写到它里面的数据。

同一线程中的不同方法共享 `t1` 持有的数据。

# 3. ThreadLocal的底层原理 #

这里就不贴源码了，先简述一下原理：

上面提到 ThreadLocal 变量有 set、get、remove 三个方法。当执行任何一个方法时，先获取当前线程。为什么要获取当前线程，因为 Thread 类中有个字段叫 `ThreadLocalMap` 类型的字段，它里面保存着所有的 ThreadLocal 变量。这是个 map， key 是 threadlocal 变量本身，value 是 threadlocal 变量所持有的变量。在上面的 demo 中，每个线程的 threadLocalMap 字段中都有储存了个键值对：`t1: i 的数据` 。

**threadlocal 变量的 set、get、remove 操作，实际上是对当前线程的 threadLocalMap 里面的键值对进行操作。**

**因为拿的是当前线程，所以不可能操作到其他线程中的键值对，从而实现了线程之间变量隔离。**

**因为拿的是当前线程，同一个线程中的不同方法拿到的当前线程肯定是一样的，所以能够操作相同的键值对，从而实现了同一线程中不同方法之间的变量共享。**

> 简单看一下源码，不会走的很深，因为 threadlocalMap 是 Map 类型的，想想 HashMap 就能对里面的复杂程度有认识了，看起来不难，写起来还很费时间的。

## 3.1 set 源码 ##

public void set(T value) { 
        // 获取当前线程。
        Thread t = Thread.currentThread();
        // 从线程中拿 ThreadLocalMap 字段。
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 直接向 map 中 set 键值对。
            map.set(this, value);
        else
            // 先创建 map，再 set 键值对。
            createMap(t, value);
    }
    
    ThreadLocalMap getMap(Thread t) { 
        return t.threadLocals;
    }

## 3.2 get 源码 ##

public T get() { 
        // 获取当前线程。
        Thread t = Thread.currentThread();
        // 从线程中拿 ThreadLocalMap 字段。
        ThreadLocalMap map = getMap(t);
        if (map != null) { 
            // 自己当做 key 去 map 拿 键值对。
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) { 
                @SuppressWarnings("unchecked")
                // 获取 value。
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

## 3.3 remove 源码 ##

public void remove() { 
    	// 获取当前线程，并从线程中拿 ThreadLocalMap 字段
        ThreadLocalMap m = getMap(Thread.currentThread());
        if (m != null)
            // 把自己当做 key 从 map 中做移除操作。
            m.remove(this);
    }

# 4. ThreadLocal 的使用场景 #

我见到 ThreadLocal 用的最多的地方就是操作数据库的时候。Mybatis 底层调用的是 JDBC，之前看 spring 事务源码的时候想到。

spring 事务底层是使用 aop 实现的。核心代码如下：

// 创建事务。
    TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
    try { 
        // 执行目标方法，mybatis 框架写的SQL。
        retVal = invocation.proceedWithInvocation();
    }
    catch (Throwable ex) { 
        // 异常处理。
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    }
    finally { 
        // 清空事务。
        cleanupTransactionInfo(txInfo);
    }
    // 提交事务。
    commitTransactionAfterReturning(txInfo);

在创建 txInfo，获取并且设置了一个通向数据源的 connection。这个 connection 的引用通过 threadlocal 在当前线程中绑定了一份，也在 txInfo 中存储了一份。

异常处理、清空事务、提交事务都是传参的，所以他们能拿到同一个 connection，这个无可厚非。

mybatis 底层也是需要一个 connection 操作数据库的，那它的 connection 是怎么来的呢？

如果 mybatis 的 connection 是自己新创建的，那么它肯定和 txInfo 中的 connection 是两个不同的对象。那如果 mybatis 抛异常了，按照代码逻辑，异常处理是需要执行回滚的，两个 connection 都不一样，怎么回滚。

而且执行目标方法是没有传参的，此时 mybatis 只能通过从线程中拿之前绑定的 connection，才能将这两部分代码”融合“起来。（当然我相信mybatis 能新建 connection，不然，没了事务，mybatis还不操作数据库了）。

这是之前看 spring 事务源码时想到的点，不过还没在 mybatis 那边确认。不过我感觉自己猜的是正确的。

# 5 弱引用 #

> 这得需要聊到底层源码了，关于底层源码，如今感觉很尴尬，能看懂，能写博客，但就是真真的记不住，细节太多了。

先来看看弱引用在哪里？

众所周知，map 的底层使用散列表 table数组存储数据，那 table 中元素是什么类型的？

HashMap 中的 table 是 Node 类型的。

LocalThreadMap 中 table 是 Entity 类型的。

static class Entry extends WeakReference<ThreadLocal<?>> { 
        Object value;
    
        Entry(ThreadLocal<?> k, Object v) { 
            // threadLocal对象的引用
            super(k);
            // 绑定到当前线程的对象的引用。
            value = v;
        }
    }

threadLocal对象的引用是虚引用。

为什么要定义成虚引用？

先看下不同强度引用的作用：

*  强引用：我们最常用的`Object o = new Object();` ，一个对象只要还有强引用指向它，那么垃圾回收器绝不回收该对象。
 *  软引用：`SoftReference sr = new SoftReference(new Object())` ，内存足够时，垃圾回收器不回收它，内存不足时，就会回收该对象。
 *  弱引用：`weakReference = new WeakReference(new Object());`，当垃圾回收器扫描到一个对象只有弱引用指向它时，不管内存足不足，都会回收该对象。
 *  虚引用：`PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj,refQueue);` 只有虚引用指向的对象就跟没有引用指向是一样的，任何时候都会被垃圾回收器回收。

再来看两行代码：

ThreadLocal<String> t1 = new ThreadLocal<>();
    t1.set("要绑定的数据");

执行完这两行代码后，LocalThreadMap 的 table 数组中肯定有 entity (弱引用,“要绑定的数据”) 元素。

此时 `new ThreadLocal<>()` 是堆中的对象，

1.  栈中的 t1 是强引用，指向 `new ThreadLocal<>()`
2.  堆中的 entity 对象里面有个弱引用也指向 `new ThreadLocal<>()`

当 t1 所在的方法执行结束后，t1就不存在了，这个强引用就没了。但是因为线程没有结束，LocalThreadMap 一直存在，table一直存在，entity 一直存在，所以弱引用在线程结束前也一直存在。

此时假设如果这不是个弱引用，而是强引用。那堆中的 `new ThreadLocal<>()` 对象肯定不会被垃圾回收器回收，这就造成了内存泄露。当 entry 中是弱引用时，因为只有弱引用指向它，所以垃圾回收器可以及时将该对象回收掉。

# 6. 内存泄露 #

先说说什么是内存泄露：java 内存泄露指的是堆中的对象，有引用指向它，但是程序以后不会再使用这个对象了，占了内存却不能被使用，就叫内存泄露。

那 ThreadLocal 是怎么造成的内存泄露呢？

依旧是这两行代码

ThreadLocal<String> t1 = new ThreadLocal<>();
    t1.set("要绑定的对象的引用");

LocalThreadMap 的 table 数组中肯定有 entity (弱引用,要绑定的对象的引用) 元素，entry 元素的生命周期和线程一样长。

当 t1 所在的方法执行结束后，t1就不存在了，因为是弱引用， `new ThreadLocal<>()` 对象被 GC 回收了。但是线程在，LocalThreadMap 还在，table 还在，所以 entity (弱引用,要绑定的对象的引用) 也还在。但 entry(弱引用,要绑定的对象的引用) 不可能再被业务代码调用了，所以造成了内存泄露。

怎么解决：

1.  调用 remove 方法，手动删除 entry。
2.  等待线程执行结束，整个 LocalThreadMap 就全都没了。

> 有时候写字描述很费力，后面要尝试画图。