ThreadLocal知识点

最新推荐文章于 2024-11-04 22:26:34 发布

小马爱打代码

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量553

点赞数 23

分类专栏： Java 文章标签： java jvm

本文链接：https://blog.csdn.net/weixin_46619605/article/details/142364619

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

作用

处理并发编程的时候，其核心问题是当多个线程去访问共享变量时，因为顺序、资源分配等原因带来了数据的不准确，我们叫这种情况为线程不安全，为了解决线程安全问题，在Java中可以采用Lock、 synchronzed关键字等方式，但这种方式对于没有持有锁的线程来说会阻塞，这样以来在时间性能上就有所损失。
为了解决这个问题，Java的lang包中诞生出了一个类，名为ThreadLocal，见名知意，它被视为线程的“本地变量”，主要用来存储各线程的私有数据，当多个线程访问同一个ThreadLocal变量时，实际上它们访问的是各自线程本地存储的副本，而不是共享变量本身。因此，每个线程都可以独立地修改自己的副本，而不会影响到其他线程。这种以空间换时间的方式，可以大大的提升处理时间。

使用案例

public class TestService implements Runnable{
        // SimpleDateFormat 不是线程安全的，所以每个线程都要有自己独立的副本
        //共享变量
        private static final ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));

        public static void main(String[] args) throws InterruptedException {
            TestService obj = new TestService();
            //循环创建5个线程
            for(int i=0 ; i<5; i++){
                Thread t = new Thread(obj, ""+i);
                Thread.sleep(new Random().nextInt(1000));
                t.start();
            }
        }

        @Override
        public void run() {
            System.out.println("Thread:"+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern());
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //formatter pattern is changed here by thread, but it won't reflect to other threads
            //设置副本的值
            formatter.set(new SimpleDateFormat());
            System.out.println("Thread:"+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern());
        }
}

输出：

Thread:0 default Formatter = yyyyMMdd
Thread:1 default Formatter = yyyyMMdd
Thread:2 default Formatter = yyyyMMdd
Thread:1 formatter = yy-M-d ah:mm
Thread:0 formatter = yy-M-d ah:mm
Thread:3 default Formatter = yyyyMMdd
Thread:2 formatter = yy-M-d ah:mm
Thread:3 formatter = yy-M-d ah:mm
Thread:4 default Formatter = yyyyMMdd
Thread:4 formatter = yy-M-d ah:mm

从输出中可以看出，虽然 Thread-0 已经改变了 formatter 的值，但 Thread-1 默认格式化值与初始化值相同并没有被修改，其他线程也一样，这说明每个线程获取ThreadLocal变量值的时候，确访问的时线程本地的副本值。

原理

从Thread源码入手，看ThreadLocal的实现原理。首先，在Thread的源码中，我们看到了这样的两句定义语句：

public class Thread implements Runnable {
//......
//与此线程有关的ThreadLocal值。由ThreadLocal类维护
ThreadLocal.ThreadLocalMap threadLocals = null;

//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
//......
}

threadLocals 、inheritableThreadLocals 都是ThreadLocalMap变量，而这个Map我们可以看作是ThreadLocal的定制化HashMap，用来存储线程本地变量的容器，是一个静态内部类，而这两个变量的值初始为null，只有当前线程调用 ThreadLocal 类的 set或get方法时才创建它们，那我们继续去看set/get方法。

public void set(T value) {
 //1. 获取当前线程实例对象
    Thread t = Thread.currentThread();

 //2. 通过当前线程实例获取到ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);

    if (map != null)
    //3. 如果Map不为null,则以当前ThreadLocal实例为key,值为value进行存入
       map.set(this, value);
    else
   //4.map为null,则新建ThreadLocalMap并存入value
      createMap(t, value);
}

在ThreadLocal的set方法中通过getMap()方法去获取当前线程的ThreadLocalMap对象，并对获取到的map进行判断，我们跟如到getMap方法中去，发现其实里面返回的是初始化定义的threadLocals变量。

ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}

在threadLocals没有被调用初始化方法重新赋值的时候，它为null（不为null时，直接set进行赋值，当前ThreadLocal实例为key,值为value），set方法中会去调用createMap(t,value)进行处理，我们继续跟入这个方法的源码去看看：

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

我们可以看到，在这个方法内部，会去新构造一个ThreadLocalMap的实例，并将value值初始化进去，并赋给threadLocals。
看完了set方法的底层实现我们知道：

最终变量存储的位置在ThreadLocalMap里，ThreadLocal可以视为这个Map的封装。
无论如何最终threadLocals存储的数据都是以线程为key，对应的局部变量为值得映射表。
因为映射表的原因，确保了每个线程的局部变量都时独立的。

看完了set的源码，我们继续来看看get方法的底层实现吧，既然有存(set)就有取(get)，get 方法提供的就是获取当前线程中 ThreadLocal 的变量值的功能。

public T get() {
  //1. 获取当前线程的实例对象
  Thread t = Thread.currentThread();

  //2. 获取当前线程的ThreadLocalMap
  ThreadLocalMap map = getMap(t);
  if (map != null) {
 //3. 获取map中当前ThreadLocal实例为key的值的entry
    ThreadLocalMap.Entry e = map.getEntry(this);

    if (e != null) {
      @SuppressWarnings("unchecked")
   //4. 当前entitiy不为null的话，就返回相应的值value
      T result = (T)e.value;
      return result;
    }
  }
  //5. 若map为null或者entry为null的话通过该方法初始化，并返回该方法返回的value
  return setInitialValue();
}

我们上面提到了线程的变量值是和线程的ThreadLocal有映射关系的，所以这里将当前线程的ThreadLocal作为key去map中获取值，若map为null或者entry为null的话通过该方法初始化，并返回该方法返回的value，我们去看看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);
    return value;
}
protected T initialValue() {
    return null;
}

这个方法里的实现和set几乎一模一样，这里调用了一个protected访问修饰符的方法initialValue()，这个方法可以被子类重写。
setInitialValue 方法的目的是确保每个线程在第一次尝试访问其 ThreadLocal 变量时都有一个合适的值。
ThreadLocalMap
上面我们也说了，ThreadLocalMap是ThreadLocal的静态内部类，而每个线程独立的变量副本存储也是在这个Map中，它是一个定制的哈希表，底层维护了一个Entry 类型的数组类型的数组 table，它的内部提供了set、remove、getEntry等方法。
Entry静态内部类这个Entry又是ThreadLocalMap的一个静态内部类，我们看一下它的源码：

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

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

Entry 继承了弱引用 WeakReference<ThreadLocal<?>>，它的 value 字段用于存储与特定 ThreadLocal 对象关联的值，key 为弱引用，意味着当 ThreadLocal 外部强引用被置为 null（ThreadLocalInstance=null）时，根据可达性分析，ThreadLocal 实例此时没有任何一条链路引用它，所以系统 GC 的时候 ThreadLocal 会被回收。这种操作看似利用垃圾回收器节省了内存空间，实则存在一个风险，也就是我们下面要说的内存泄露问题。

内存泄漏

ThreadLocal的缺点是使用不当的时候，会带来内存泄漏问题。
强软弱虚引用
在Java中，引用（Reference）是一种对象的引用方式，它允许程序通过引用来访问内存中的对象。Java提供了四种类型的引用，分别是强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。每种引用类型都决定了对象的生命周期和垃圾回收器如何回收对象。
强引用（Strong Reference）：
○ 这是最常见的引用类型，如果一个对象具有强引用，那么它永远不会被垃圾回收器回收，直到这个引用被显式地设置为null，即使内存空间不足时也不会被回收。
○ 示例：Object obj = new Object(); 这里obj就是一个强引用。
软引用（Soft Reference）：
○ 软引用关联着的对象，在内存充足的情况下不会被回收，但是在内存不足时，垃圾回收器会考虑回收这些对象以释放内存。
○ 软引用可以用来实现内存敏感的高速缓存。
○ 示例：SoftReference softRef = new SoftReference<>(new Object());
弱引用（Weak Reference）：
○ 弱引用关联的对象，只要垃圾回收器发现了它，不管当前内存空间足够与否，都会回收其指向的对象。
○ 弱引用可以让我们跟踪对象的存在但不阻止垃圾回收器的回收工作，通常用于实现缓存。
○ 示例：WeakReference weakRef = new WeakReference<>(new Object());
虚引用（Phantom Reference）：
○ 一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获取一个对象的实例。
○ 虚引用的主要作用是跟踪对象被垃圾回收的活动，比如用于清除关联资源。
○ 示例：PhantomReference phantomRef = new PhantomReference<>(new Object(), null);
在实际应用中，软引用、弱引用和虚引用通常用于内存敏感的场合，比如缓存系统，它们提供了一种更加灵活的内存管理机制。通过合理使用这些引用类型，可以减少内存泄露的风险，并且提高程序的健壮性。

内存泄漏是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。
上述的分析中，我们知道ThreadLocalMap中的使用的key是ThreadLocal的弱引用，Value为强引用，如果ThreadLocal没有被强引用的话，key会被GC掉，而value依旧存在，若我们采用任何措施的前提下，线程一直运行，那这些value值就会一直存在，过多的占用内存，导致内存泄漏。
如何解决内存泄漏呢，只需要记得在使用完 ThreadLocal 中存储的内容后将它 remove 掉就可以了。
ThreadLocal提供的清理方法

//ThreadLocal提供的清理方法
public void remove() {
 //1. 获取当前线程的ThreadLocalMap
 ThreadLocalMap m = getMap(Thread.currentThread());
  if (m != null)
  //2. 从map中删除以当前ThreadLocal实例为key的键值对
  m.remove(this);
}
/**
 * ThreadLocalMap中的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) {
   //将entry的key置为null
            e.clear();
   //将该entry的value也置为null
            expungeStaleEntry(i);
            return;
        }
    }
}

除此之外，我们还可以使用Java 8引入的InheritableThreadLocal来替代ThreadLocal，它可以在子线程中自动继承父线程的线程局部变量值，从而避免在创建新线程时重复设置值的问题。但是同样需要注意及时清理资源以避免内存泄漏。

线程间局部变量传值问题

上面我们提到的Java8中引入的InheritableThreadLocal类，这是实现父子线程间局部变量传值的关键。InheritableThreadLocal存在于java.lang包中是ThreadLocal的扩展，它有一个特性，那就是当创建一个新的线程时，如果父线程中有一个 InheritableThreadLocal 变量，那么子线程将会继承这个变量的值。这意味着子线程可以访问其父线程为此类变量设置的值。

public class TestService{
    // 创建一个 InheritableThreadLocal 变量
    private static final InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        // 在主线程中设置值
        inheritableThreadLocal.set("这是父线程的值");

        System.out.println("父线程中的值: " + inheritableThreadLocal.get());

        // 创建一个子线程
        Thread childThread = new Thread(() -> {
            // 在子线程中尝试获取值，由于使用了 InheritableThreadLocal，这里会获取到父线程中设置的值
            System.out.println("子线程中的值: " + inheritableThreadLocal.get());
        });

        // 启动子线程
        childThread.start();

        // 等待子线程执行完成
        try {
            childThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 主线程结束时清除值，防止潜在的内存泄漏
        inheritableThreadLocal.remove();
    }
}

输出

父线程中的值: 这是父线程的值
子线程中的值: 这是父线程的值

父子线程局部变量传值的实现原理

我们看到上面的输出后，应该思考这样的一个问题：子线程是怎么拿到父线程的inheritableThreadLocal值得呢？其实要从子线程的初始化开始说起，在线程Thread的内部，有着这样的一个初始化方法：

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  // 该参数一般默认是 true
                  boolean inheritThreadLocals) {
  // 省略大部分代码
  Thread parent = currentThread();
  
  // 复制父线程的 inheritableThreadLocals 属性，实现父子线程局部变量共享
  if (inheritThreadLocals && parent.inheritableThreadLocals != null) {
       this.inheritableThreadLocals =
    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); 
  }
    // 省略部分代码
}

在这里将父线程的inheritableThreadLocals赋值了进来，我们跟入createInheritedMap方法中继续解析：

// 返回一个ThreadLocalMap,传值为父线程的
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
  return new ThreadLocalMap(parentMap);
}
//ThreadLoaclMap构建的过程中会调用该构造方法
private ThreadLocalMap(ThreadLocalMap parentMap) {
  Entry[] parentTable = parentMap.table;
  int len = parentTable.length;
  setThreshold(len);
  table = new Entry[len];
    // 一个个复制父线程 ThreadLocalMap 中的数据
  for (int j = 0; j < len; j++) {
    Entry e = parentTable[j];
    if (e != null) {
      @SuppressWarnings("unchecked")
      ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
      if (key != null) {
        // childValue 方法调用的是 InheritableThreadLocal#childValue(T parentValue)
        Object value = key.childValue(e.value);
        Entry c = new Entry(key, value);
        int h = key.threadLocalHashCode & (len - 1);
        while (table[h] != null)
          h = nextIndex(h, len);
        table[h] = c;
        size++;
      }
    }
  }
}

在这个构造方法中，我们终于看到了InheritableThreadLocal的身影，childValue()方法就是其中的一个方法，用来给子线程赋父线程的inheritableThreadLocals值；其实InheritableThreadLocal的源码非常非常的简单，大部分的实现都取自父类ThreadLocal。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {

    protected T childValue(T parentValue) {
        return parentValue;
    }

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

使用场景

数据库连接和会话管理：在多线程环境下，每个线程可能需要独立的数据库连接或会话，使用 ThreadLocal
可以确保每个线程获取到自己的数据库连接或会话，而不会相互干扰。
事务管理：在处理事务时，每个线程可能需要维护自己的事务状态，使用 ThreadLocal 可以确保事务状态的隔离性。
用户会话信息：在 Web 应用中，每个用户会话可能包含特定于用户的信息，如用户ID、权限等。使用 ThreadLocal
可以方便地在多个组件之间传递这些信息。
日志记录：在多线程应用程序中，可以为每个线程设置独立的日志记录器，其中包含线程特定的信息，如线程ID或执行的业务逻辑。
缓存：可以为每个线程创建独立的缓存实例，以减少锁的使用并提高性能。
线程局部的资源：当需要为每个线程分配特定的资源时，如临时缓冲区、线程特定的配置信息等，可以使用 ThreadLocal 来实现。
避免共享资源的同步：通过为每个线程提供独立的变量副本，可以减少对共享资源的争用，从而减少同步操作，提高并发性能。
测试和模拟：在单元测试中，可以使用 ThreadLocal 来模拟多线程环境，或者在测试中隔离每个测试用例的状态。
异步处理：在异步编程中，可以为每个异步任务分配独立的上下文信息，这些信息在任务执行过程中被使用。