Java：关于 ThreadLocal 的知识来了！

最新推荐文章于 2023-10-22 11:06:39 发布

置顶 CodeAli

最新推荐文章于 2023-10-22 11:06:39 发布

阅读量1.2k

点赞数 2

分类专栏： Java并发编程文章标签： java jvm 多线程

本文链接：https://blog.csdn.net/weixin_50280576/article/details/113849450

版权

Java并发编程专栏收录该内容

5 篇文章 45 订阅

订阅专栏

面试题：
1、ThreadLocal 与 ThreadLocalMap 的数据结构和关系？
2、ThreadLocal 的 key 是弱引用，这是为什么？
3、ThreadLocal 内存泄漏问题你知道吗?
4、ThreadLocal 中最后为什么要加 remove 方法？

一、ThreadLocal 简介

1、ThreadLocal 是什么？

ThreadLocal 能提供线程局部变量，这些变量与正常的变量不同，因为每一个线程在访问 ThreadLocal 实例的时候（通过 get 或 set 方法）都有自己独立初始化的变量副本，ThreadLocal 实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户 ID 或者事务 ID）关联起来。

2、ThreadLocal 能干什么？

ThreadLocal 能实现每一个线程都有自己专属的本地变量副本，主要解决了让每个线程绑定自己的值，通过使用 get(）和 set() 方法，获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全问题。

3、ThreadLocal 常用的 API 介绍

/**
返回该线程局部变量在当前线程副本中的值。如果该变量对于当前线程没有值，它首先被初始化调用 initialValue 方法得到返回的值。
*/
public T get() {}
/**
返回当前线程的这个线程局部变量的“初始值”。该方法将在线程第一次使用 get 方法访问变量时被调用
除非线程之前调用了set 方法，在这种情况下，initialValue 方法将不会被线程调用。
通常，这个方法在每个线程中最多调用一次，但是在后续调用 remove 和 get 的情况下，它可能会被再次调用。
*/
protected T initialValue() {
	return null;
}
/**
删除当前线程局部变量的值。如果这个线程局部变量随后被当前线程调用了 get ，它的值将通过调用它的 initialValue 方法重新初始化，除非它的值在过渡期间被当前线程调用了 set 。这可能导致在当前线程中多次调用 initialValue 方法。
*/
public void remove() {}
/**
将当前线程的这个线程局部变量的副本设置为指定的值。大多数子类将不需要覆盖这个方法，仅仅依靠 initialValue 方法来设置线程局部变量的值
*/
public void set(T value) {}
/**
创建线程局部变量。变量的初始值是通过方法上 Supplier 的 get 方法来确定的。jdk1.8 才有的。
*/
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {}

二、ThreadLocal 简单使用

1、问题引出

首先，看一个卖票的场景，代码如下：

public class Code_19_ThreadLocalTest {

    public static void main(String[] args) {

        MovieTicket movieTicket = new MovieTicket();

        new Thread(() -> {for(int i = 0; i < 3; i++) {movieTicket.saleTicket();}}, "t1").start();
        new Thread(() -> {for(int i = 0; i < 3; i++) {movieTicket.saleTicket();}}, "t2").start();
        new Thread(() -> {for(int i = 0; i < 3; i++) {movieTicket.saleTicket();}}, "t3").start();

        try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println("****总卖出去的票：" + movieTicket.ticketNumber);
    }

}

class MovieTicket {

    public int ticketNumber = 0;

    public synchronized void saleTicket() {
        System.out.println(Thread.currentThread().getName() + "\t 卖出第:" + (++ticketNumber) + "票");
    }
    
}

如上代码，使用 3 个线程进行卖票，由于 ticketNumber 是每个线程共享的资源，存在线程安全问题，所以使用 synchronized 加锁，上面的代码存在的问题是，多个线程只有一把锁，只有当上一个线程释放锁，才有机会拿到锁，这是因为多个线程使用的是一个共享的变量，如果说每个线程都有自己的本地副本变量，那么也就不会存在线程安全问题，是一种不加锁的方式解决线程安全问题。

2、使用 ThreadLocal 解决

public class Code_19_ThreadLocalTest {

    public static void main(String[] args) {

        MovieTicket movieTicket = new MovieTicket();

        new Thread(() -> {
            movieTicket.run(3);
        }, "t1").start();

        new Thread(() -> {
            movieTicket.run(5);
        }, "t2").start();

        new Thread(() -> {
            movieTicket.run(7);
        }, "t3").start();

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        movieTicket.run(0);
    }

}

class MovieTicket {

    private static final ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> new Integer(0));

    public void run(Integer loopNumber) {
        for(int i = 0; i < loopNumber; i++) {
            saleTicketByThreadLocal();
        }
        System.out.println(Thread.currentThread().getName() + "\t 卖出第:" + threadLocal.get() + "票");
    }

    public void saleTicketByThreadLocal() {
        Integer number = threadLocal.get();
        ++number;
        threadLocal.set(number);
    }

    public int ticketNumber = 0;

    public synchronized void saleTicket() {
        System.out.println(Thread.currentThread().getName() + "\t 卖出第:" + (++ticketNumber) + "票");
    }
}

结果如下：

t1	 卖出第:3票
t2	 卖出第:5票
t3	 卖出第:7票
main	 卖出第:0票

可以看到，在没有使用锁的情况下，使用 ThreadLocal 让每个线程都保存一份本地副本变量进行操作，也可以清楚的看到 main 线程没有调用 saleTicketByThreadLocal 方法，所以主线程的本地副本变量是初始化 ThreadLocal 的值，也证明了本地变量是每个线程私有的一部分。

如上代码总结：

每个线程内有自己的实例副本且副本只能由当前线程使用
其他的线程不可以方法，本地副本变量属于线程私有，那就不存在多线程共享问题。
统一设置初始化，但是每个线程对值的修改都是独立的。

三、ThreadLocal 使用规范

1、演示 SimpleDateFormat 线程安全问题

/**
 * 演示 SimpleDateFormat 线程安全问题
 * @author 尼古
 * @date 2021/2/18 20:33
 */
public class DateUtils {

    private static final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    // 模拟多线程, 使用 parse 方法，将字符串转换为 Date 对象
    public static Date parseDate(String date) throws ParseException {
        return dateFormat.parse(date);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    System.out.println(DateUtils.parseDate("2021-02-18 20:30:30"));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

}

结果如下：

Exception in thread "Thread-8" java.lang.NumberFormatException: For input string: ""
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:601)
	at java.lang.Long.parseLong(Long.java:631)
	at java.text.DigitList.getLong(DigitList.java:195)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.ali.juc.test3.DateUtils.parseDate(DateUtils.java:18)
	at com.ali.juc.test3.DateUtils.lambda$main$0(DateUtils.java:25)
	at java.lang.Thread.run(Thread.java:748)
Thu Feb 18 20:30:30 CST 2021
Thu Feb 18 20:30:30 CST 2021
Thu Feb 18 20:30:30 CST 2021
Thu Feb 18 20:30:30 CST 2021
Thu Feb 18 20:30:30 CST 202

Process finished with exit code 0

多线程下使用 SimpleDateFormat 有线程安全问题，如果非要使用，建议为每个线程创建独立的格式实例，如果多线程同时访问一个格式，则它必须保持外部同步。

2、解决方法

1）解决方法一

将 SimpleDateFormat 定义为局部变量，代码如下：

public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
//                    System.out.println(DateUtils.parseDate("2021-02-18 20:35:30"));
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    System.out.println(dateFormat.parse("2021-02-18 20:35:30"));
                    dateFormat = null;
                } catch (ParseException e) {
                    e.printStackTrace();
                }

            }).start();
        }
    }

上述代码的缺点是，多个线程创建了多个 SimpleDateFormat 对象，方法结束又要作为垃圾回收。

2）解决方法二

使用 ThreadLocal ，也叫做线程本地变量或者线程本地存储。代码如下：

// 使用 ThreadLocal 解决
    private static final ThreadLocal<DateFormat> df = ThreadLocal.withInitial(() ->
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    public static Date parseDateByThreadLocal(String date) throws ParseException {
        return df.get().parse(date);
    }

3）其他方法，加锁或者第三方库。

3、阿里 Java 开发手册规范

在阿里 java 开发手册中第一章编程规范，并发处理中的第 5 条中规定如下。
在这里插入图片描述
参考手册演示使用 DateTimeFormatter 代码如下：

	private static final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static String format(LocalDateTime localDateTime) {
        return dtf.format(localDateTime);
    }

    public static LocalDateTime parse(String date) {
        return LocalDateTime.parse(date, dtf);
    }

还有一个使用规范，就是使用完 ThreadLocal 变量后，需要调用 remove 方法回收，在内存泄漏问题会讲到。

四、ThreadLocal 实现原理

下面这张图描述了 Thread、ThreadLocal、ThreadLocalMap 的关系，在 Thread 中的 threadLocals 与 inheritableThreadLocals 都是 ThreadLocal 静态内部类 ThreadLocalMap 的变量引用，默认都 null，所以说每一个线程都有一个 threadLocals 变量属于 ThreadLocalMap 类型，并且 ThreadLocalMap 类当中维护一个 Entry 的静态内部类，用于存放 key, value 其中 key 为弱引用。下面我们通过查看 ThreadLocal 的 set 、get 以及 remove 方法来查看 ThreadLocal 具体实怎样工作的。

	ThreadLocal.ThreadLocalMap threadLocals = null;
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

在这里插入图片描述

1、set 方法源码

	// 作用：将当前线程的这个线程局部变量的副本设置为指定的值
	public void set(T value) {
		// 1）拿到当前线程
        Thread t = Thread.currentThread();
        // 2）通过线程内部的 threadLocals 变量，拿到对应 ThreadLocalMap 对象。对应着分析1
        ThreadLocalMap map = getMap(t);
        // 3）判断如果不为 null ,则直接调用 ThreadLocalMap 中的 set 方法，传入 当前的 ThreadLocal 对象和要指定修改的值 value，对应着分析2
        if (map != null)
            map.set(this, value);
        else
        // 4）创建 map 为 null，就创建 map, 对应着分析3
            createMap(t, value);
    }

分析1：

 // 分析1 获取线程的 ThreadLocalMap 对象。
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    class Thread implements Runnable {
		ThreadLocal.ThreadLocalMap threadLocals = null;
	    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
	}

分析2：

	// 进行修改 or 新建操作, 传入 key 为当前线程的 ThreadLocal, 
	// value 是需要指定的值, 是 ThreadLocalMap 内部的 set 方法
	// 通过 & 上 数组长度 - 1, 找到对应 Entry 数组的下标
	// 如果存在, 则判断 key 是否相同, 如果相同则进行一个修改操作, 否者就进行一个 添加操作
	// 如果不存在，则直接新建一个 Entry, 然后判断数组元素的数量是否大于了扩容阈值, 如果大于了则进行扩容操作
	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;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                if (k == key) {
                    e.value = value;
                    return;
                }
                // 清理 key 为 null 值
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

分析3：

	// 直接调用了 ThreadLocalMap 的有参构造. 创建和初始化一起完成。
	void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
    
	ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    		// 创建一个默认长度大小为 16 的 Entry 数组
            table = new Entry[INITIAL_CAPACITY];
            // 计算对应的数组的下标
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            // 插入节点
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            // 设置扩容阈值
            setThreshold(INITIAL_CAPACITY);
        }

2、get 方法源码

	// 作用：返回该线程局部变量在当前线程副本中的值
	public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
        	// 通过 getEntry 找到线程对应着的 Entry 对象, 对应着分析1
            ThreadLocalMap.Entry e = map.getEntry(this);
            // 如果不为 null 则直接拿到返回
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 如果为 null , 就会调用 initialValue 方法, 拿到初始值。对应着分析 2
        return setInitialValue();
    }

分析1：

	// ThreadLocalMap 类的方法
	private Entry getEntry(ThreadLocal<?> key) {
			// 计算出 index 的值
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            // 如果存在, 判断是不是相同的对象，是就直接返回
            if (e != null && e.get() == key)
                return e;
            else
            	// 清空 key 为 null 的对象
                return getEntryAfterMiss(key, i, e);
        }

分析2：

private T setInitialValue() {
		// 会进行初始化, 如果我们重写了就会调用我们自己重写的，否则就调用默认的。
		// protected T initialValue() {return null;}
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
         // 如果 map 不为 null ，就直接添加本地变量，key 为当前线程，值为添加的本地变量值
        if (map != null)
            map.set(this, value);
        else
        // 如果 map 为 null，说明首次添加，需要首先创建出对应的 map
            createMap(t, value);
        return value;
    }

3、remove 方法源码

public void remove() {
    // 获取当前线程绑定的 threadLocals
     ThreadLocalMap m = getMap(Thread.currentThread());
     // 如果 map 不为 null，就移除当前线程中指定 ThreadLocal 实例的本地变量
     if (m != null)
         m.remove(this);
 }

4、withInitial 方法

 // 创建线程局部变量。
 // 变量的初始值是通过方法上 Supplier 的 get 方法来确定的。
 // jdk1.8 才有的。
 public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }

小结：
如下图所示：每个线程内部有一个名为 threadLocals 的成员变量，该变量的类型为 ThreadLocal.ThreadLocalMap 类型（类似于一个HashMap），其中的 key 为当前定义的 ThreadLocal 变量的 this 引用，value 为我们使用 set 方法设置的值。每个线程的本地变量存放在自己的本地内存变量threadLocals 中，如果当前线程一直不消亡，那么这些本地变量就会一直存在（所以可能会导致内存溢出），因此使用完毕需要将其 remove 掉。
在这里插入图片描述

五、ThreadLocal 内存泄漏问题

1、基本概念

1）什么是内存泄漏

不再会使用的对象或者变量占用的内存不能被回收，就是内存泄漏。

2）回顾一下 ThreadLocalMap 中 Entry 的实现。

static class ThreadLocalMap {

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

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

ThreadLocalMap 与 WeakReference 关系

ThreadLocalMap 从字面上就可以看出这是一个保存 ThreadLocal 对象的 map（其实是以它为 key），不过经过了两层包装的 ThreadLocal 对象：

第一层包装是使用 WeakReference<ThreadLocal<?>> 将 Thread 对象变成一个弱引用对象。
第二层包装是定义了一个专门的类 Entry 来扩展 WeakReference<ThreadLocal<?>>

3）回顾一下 JVM 中的强、软、弱、虚四种引用类型。
在这里插入图片描述
Object 中 finalize 方法作用是：允许使用 finalize() 方法在垃圾收集器将对象内存中清除出去之前做必要的工作。

强引用：一般我们 new 关键字创建的对象就是 Reference（强引用），当内存不足时，JVM 开始垃圾回收，对于强引用对象，就算是出现 OOM 也不会对该对象进行回收。

软引用：软引用是一种相对相对于强引用弱化了一些的引用，需要用 SoftReference 类实现，对于软引用来说，当系统内存充足时，软引用对象不会被垃圾回收，不充足时，会被回收。软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！

弱引用：弱引用需要用 WeakReference 类实现，它比软引用的生存期更短，对于弱引用对象来说，只要垃圾回收器运行，不管 JVM 内存空间是否足够，都会回收该对象占用的内存。

虚引用：虚引用需要 PhantomReference 类来实现，如果一个对象持有虚引用，那么它就和没有任何引用一样，在任何时候都可能会垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列（ReferenceQueue）联合使用。
虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被 finalize 以后，做某些事情的机制。PhantomReference 的 get 方法总是返回 null ,因此无法访问对应的引用对象。
其意义在于：说明一个对象已经进入 finalization 阶段，可以被 gc 回收，用来实现比 finalization 机制更灵活的回收操作。
换句话说，设置虚引用关联的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。

2、ThreadLocal 为什么将 Entry 设置为弱引用？

在这里插入图片描述
每个 Thread 对象维护着一个 ThreadLocalMap 的引用，ThreadLocalMap 是 ThreadLocal 内部类，用 Entry 来进行存储，

调用 ThreadLocal 的 set() 方法时，实际上就是往 ThreadLocalMap 设置值，key 是 ThreadLocal 对象，值 value 是传递进来的对象。

调用 ThreadLocal 的 get() 方法时，实际上就是往 ThreadLocalMap 获取值，key 是 ThreadLocal 对象。

所以 ThreadLocal 本身并不存储值，它只是一个自己作为 key 来让线程从 ThreadLocalMap 中获取 value，正因为这个原因，所以 ThreadLocal 能实现数据隔离，获取当前线程的局部变量值，不受其他线程影响。

看一段代码：

public void method() {
        ThreadLocal<Integer> tl = new ThreadLocal<>();
        tl .set(2021);
        tl .get();
    }

在这里插入图片描述

如图和代码可知，当调用 method 方法时，会向栈中插入一条栈帧，通过 new 关键字创建了一个 ThreadLocal 对象，tl 是对象的引用，因为是 new 创建的则是一个强引用，通过 set 方法会调用 ThreadLocalMap 中的 set 方法，如果对象不存在，那么就会创建一个 Entry，key 是 ThreadLocal，value 是值，由于 Entry 继承了 WeakReference，所以 Entry 中的 key 是弱引用指向这个对象。

为什么源码需要使用弱引用？

当 method 方法执行完毕后，栈帧销毁，强引用 tl 也就没有了。

但此时线程的 ThreadLocalMap 里某个 Entry 的 key 引用还指向这个对象。

若这个 key 引用是强引用，就会导致 key 指向的 ThreadLocal 对象是强引用对象不能被 gc 回收，造成内存泄漏;

若这个 key 引用是弱引用，就大概率会减少内存泄漏的问题。使用弱引用，就可以使 ThreadLocal 对象在方法执行完毕后顺利被回收且 Entry 的 key 引用指向为 null。

简单的说：

在方法调用的时候会创建 ThreadLocal 对象，就有一个强引用指向它，在调用 set() 后，线程的 ThreadLocalMap 对象里的 Entry 对象又有一个引用 key 指向它。如果后面这个引用 key 是强引用就会使方法执行完，栈帧中的强引用销毁了，对象还不能回收，造成严重的内存泄漏。

3、错误使用会导致内存泄漏问题

之前说了，如果是强引用会造成对象得不得释放会造成内存泄漏问题，如果是弱引用，虽然对象被置为 null 了，但是由于 Map 的结构，允许 null 的 key 和 value，从而导致有大量的 null 值。

虽然弱引用，保证了 key 指向的 ThreadLocal 对象能被及时回收，但是 v 指向的 value 对象是需要 ThreadLocalMap 调用 get 、set 时发现 key 为 null 时才会去回收整个 entry、value，因此弱引用不能 100% 保证内存不泄露。我们要在不使用某个 ThreadLocal 对象后，手动调用 remove 方法来清除它，尤其是在线程池中，不仅仅是内存泄露的问题，因为线程池中的线程是重复使用的，意味着这个线程的 ThreadLocalMap 对象也是重复使用的，如果我们不手动调用 remove 方法，那么后面的线程就有可能获取到上个线程遗留下来的 value 值，造成 bug。

正确使用方式如下：
在这里插入图片描述

六、总结

1）ThreadLocal 并不解决线程间共享数据的问题

2）ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景

3）ThreadLocal 通过隐式的在不同线程内创建独立实例变量副本避免了实例线程安全的问题

4）每个线程持有一个只属于自己的专属 Map 并维护了 ThreadLocal 对象与具体实例的映射，该 Map 由于只被持有它的线程访问，故不存在线程安全以及锁的问题

5）ThreadLocalMap 的 Entry 对 ThreadLocal 的引用为弱引用，避免了ThreadLocal 对象无法被回收的问题

6）ThreadLocalMap 的 set 方法通过调用 replaceStaleEntry 方法回收键为null 的 Entry 对象的值(即为具体实例) 以及 Entry 对象本身从而防止内存泄漏

群雄逐鹿起纷争，人各一份天下安！

看完了，相信你也理解了 ThreadLocal ，来看看刚刚的面试题，我相信你心中也会有了答案。
1、ThreadLocal 与 ThreadLocalMap 的数据结构和关系？
2、ThreadLocal 的 key 是弱引用，这是为什么？
3、ThreadLocal 内存泄漏问题你知道吗?
4、ThreadLocal 中最后为什么要加 remove 方法？