关于ThreadLocal,可能很多同学在学习Java的并发编程部分时,都有所耳闻,但是如果要仔细问ThreadLocal是个啥,我们可能也说不清楚,所以这篇博客旨在帮助大家了解ThreadLocal到底是个啥?

1.ThreadLocal是什么?

首先,我们要知道的是,ThreadLocal类位于Java标准库的java.lang包中,它是Java中的一个类,我们可以用它来声明一个ThreadLocal变量,如下:

ThreadLocal<String> local = new ThreadLocal<>();

好的,接下来解释一下ThreadLocal的含义:

它从名字上看,叫做本地线程变量,意思是说,ThreadLocal中填充的的是当前线程的变量,该变量对其他线程而言是封闭且隔离的,ThreadLocal为变量在每个线程中创建了一个副本,这样每个线程都可以访问自己内部的副本变量。

相信上面的文字描述大家会不太理解,简单来说,就是用ThreadLocal创建的变量,我们可能会在不同的线程中用到,那么为了避免线程安全问题,每个线程都会为自己单独存一份这个变量,并且单独使用和修改这个变量,这样不同的线程之间就各自使用各自的ThreadLocal变量,互不影响。

但是到底具体每个线程是怎样存储的这个变量,以及这个变量如何被这个线程调用,这些的底层是如何实现的,请接着向下看。

2.举例

大家先看一个例子:

public class ThreadLocalTest02 {

    public static void main(String[] args) {
//创建一个ThreadLocal变量,名为local
        ThreadLocal<String> local = new ThreadLocal<>();
//创建10个线程,并且每次都在不同的线程中加入这个local变量
        IntStream.range(0, 10).forEach(i -> new Thread(() -> {
//使用set方法设置加入的local内容
            local.set(Thread.currentThread().getName() + ":" + i);
//然后输入当前线程存储的local变量的信息
            System.out.println("线程:" + Thread.currentThread().getName() + ",local:" + local.get());
        }).start());
    }
}

结果如下:

输出结果:
线程:Thread-0,local:Thread-0:0
线程:Thread-1,local:Thread-1:1
线程:Thread-2,local:Thread-2:2
线程:Thread-3,local:Thread-3:3
线程:Thread-4,local:Thread-4:4
线程:Thread-5,local:Thread-5:5
线程:Thread-6,local:Thread-6:6
线程:Thread-7,local:Thread-7:7
线程:Thread-8,local:Thread-8:8
线程:Thread-9,local:Thread-9:9

上面的结果说明了什么呢?我们在每个线程中都添加了local对象,并且内容是不同的,然后我们再使用get方法输出local的值。我们发现,我们只使用了一个local对象,但是在十个线程中的值都是不同的,而且它们的值不会相互影响,这就是ThreadLocal的简单应用。不同的线程对这个local对象有着自己的备份。

3.Set方法

请大家先仔细阅读一下下面这段源码,逻辑一点也不难,我加了注释:

public class ThreadLocal<T> {

    public void set(T value) {
//先获取当前线程,例如在线程1中调用了local.set方法,那么这个t就是线程1
        Thread t = Thread.currentThread();

//然后获取当前线程1中的ThreadLocalMap
        ThreadLocalMap map = getMap(t);


//如果map为空,说明此线程还没有存入任何一个ThreadLocal对象,我们就创建一个ThreadLocalMap
//如果map不为空,那么我们就直接将value存入这个ThreadLocalMap中
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

大家现在可能会有疑惑,什么是ThreadLocalMap啊?为啥是从当前线程中获取啊?还有createMap方法,到底是干啥的捏?我们一一进行解释:

什么是ThreadLocalMap?

我们刚才上面说,我们每个线程都会存储ThreadLocal对象的备份,那么存储在哪里呢,答案就是在ThreadLocalMap中,ThreadLocalMap为 ThreadLocal的一个静态内部类,里面定义了Entry来保存数据,那么既然是map,就会有键值对的结构,键的位置存的就是我们的ThreadLocal对象,而值存储的就是通过set方法存入的那个值,例如这一句代码:local.set( i);那么存到这个线程中的ThreadLocalMap的一个entry中,键和值就分别是 local:i

接下来我们就看一下ThreadLocalMap(它是ThreadLocal的一个内部类,还有Entry的结构:

  // 内部类ThreadLocalMap
    static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            // 内部类Entry,实际存储数据的地方
            // Entry的key是ThreadLocal对象,不是当前线程ID或者名称
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        // 注意这里维护的是Entry数组
        private Entry[] table;
    }

可以看出实际上存储数据的是Entry,而TheadLocalMap则是一个Entry数组;

ok,了解了这个结构后,我们又回到宏观的角度看待一下问题,刚才说每个线程都有自己的备份,并且这些备份是当前线程独有的,那么既然上面说存储数据的是ThreadLocalMap,并且每个线程都有自己的独有的一份,那么这个ThreadLocalMap到底存在哪里呢?答案就是:ThreadLocalMap是作为Thread类的一个私有属性实现的,这样就可以保证每个Thread线程都有自己独一份的TheadLocalMap来存储自己的Threadlocal变量。

public class Thread {
    /* ... 省略其他代码 ... */

    /**
     * ThreadLocalMap实例,用于存储ThreadLocal变量的键值对
     */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /* ... 省略其他代码 ... */
}

 好好好,现在我们算是知道了,原来为每个线程存储这些ThreadLocal变量的,就是Thread类中的属性threadLocals 

那么这样我们就能解释为什么要从线程中获取map了,看一下刚才的set方法中的这一句,我们就知道为啥要从线程中获取了:

//然后获取当前线程1中的ThreadLocalMap
        ThreadLocalMap map = getMap(t);

接着就是后面的代码,相信大家也就能明白为什么要这样写啦:

//如果map为空,说明此线程还没有存入任何一个ThreadLocal对象,我们就创建一个ThreadLocalMap
//如果map不为空,那么我们就直接将value存入这个ThreadLocalMap中
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

这是createMap方法,看到它给什么赋值吗,就是我们刚才说的Thread线程类中的那个存储ThreadLocalMap的属性哦~

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

ok,set方法就介绍到这里了

4.get方法

get方法的作用很简单,它通过local对象调用,返回当前线程的以local对象为键,对应的那个值即可;例如 System.out.println(local.get());就是输出当前线程的local对象当时通过set方法存入的值。

get方法的源码如下:

    public T get() {
//先获取当前调用get方法的线程
        Thread t = Thread.currentThread();

//然后获取此线程的ThreadLocalMap对象,这里面存储着local键值对
        ThreadLocalMap map = getMap(t);

/*如果map不为空,就在map里面寻找键为this的entry,为什么是this呢,因为当前类
是ThreadLocal类,而get方法通过local.get()的方式调用,所以这里的this就指的
是这个local对象,也就是entry的键。如果找的了这个以local为键的entry,我们就
返回对应的值即可。
*/
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

ok,ThreadLocal的具体应用和get方法就介绍到这里

5.ThreadLocal的结构

有了上面的基础,我们现在来看一下他在内存中的结构:

6.内存泄漏问题

仔细看下ThreadLocal内存结构就会发现,Entry数组对象通过ThreadLocalMap最终被Thread持有,并且是强引用。也就是说Entry数组对象的生命周期和当前线程一样。即使ThreadLocal对象被回收了,Entry数组对象也不一定被回收,这样就有可能发生内存泄漏。ThreadLocal在设计的时候就提供了一些补救措施:

  • Entry的key是弱引用的ThreadLocal对象,很容易被回收,导致key为null(但是value不为null)。所以在调用get()、set(T)、remove()等方法的时候,会自动清理key为null的Entity。
  • remove()方法就是用来清理无用对象,防止内存泄漏的。所以每次用完ThreadLocal后需要手动remove()。

解决办法:使用完ThreadLocal后,执行remove操作,避免出现内存溢出情况。

如同 lock 的操作最后要执行解锁操作一样,ThreadLocal使用完毕一定记得执行remove 方法,清除当前线程的数值。如果不remove 当前线程对应的VALUE ,就会一直存在这个值。

这里复习一下对象的强引用、软引用、弱引用

1.强引用

我们平日里面的用到的new了一个对象就是强引用,例如 Object obj = new Object();当JVM的内存空间不足时,宁愿抛出OutOfMemoryError使得程序异常终止也不愿意回收具有强引用的存活着的对象!

2.软引用

当JVM认为内存空间不足时,就回去试图回收软引用指向的对象,也就是说在JVM抛出OutOfMemoryError之前,会去清理软引用对象。

3.弱引用

在GC的时候,不管内存空间足不足都会回收这个对象,同样也可以配合ReferenceQueue 使用,也同样适用于内存敏感的缓存。ThreadLocal中的key就用到了弱引用。

7.最后我们还要知道为什么要使用ThreadLocal?

ThreadLocal类在多线程编程中有几个重要的用途和优势:

  1. 线程隔离:ThreadLocal提供了一种将数据与线程关联的机制。通过使用ThreadLocal,可以为每个线程创建独立的变量副本,使得每个线程都可以独立地访问和修改自己的变量副本,而不会干扰其他线程的数据。这样可以实现线程间的数据隔离,避免了线程安全问题。

  2. 状态传递:ThreadLocal可以用于在同一个线程的多个方法之间传递状态信息,而无需在方法参数中显式传递。通过将状态信息存储在ThreadLocal变量中,不同的方法可以通过ThreadLocal访问和修改共享的状态,而无需显式传递参数。这样可以简化方法的调用,提高代码的可读性和可维护性。

  3. 线程上下文管理:有些情况下,需要在整个线程执行期间共享某些上下文信息,比如用户认证信息、数据库连接等。通过将这些信息存储在ThreadLocal中,可以在同一线程的任何地方方便地访问和使用这些信息,而无需显式传递或在每个方法中重复获取。

  4. 避免锁竞争:在某些情况下,使用ThreadLocal可以避免使用锁来同步对共享变量的访问。由于每个线程都有自己的变量副本,线程之间不会产生竞争条件,从而避免了锁竞争和同步开销,提高了程序的性能。

Logo

助力合肥开发者学习交流的技术社区,不定期举办线上线下活动,欢迎大家的加入

更多推荐