Java并发编程之ThreadLocal

yyangqqian

已于 2022-04-11 22:22:55 修改

阅读量1.1k

点赞数

分类专栏： # Java并发编程文章标签： java 开发语言后端

于 2019-04-24 16:40:27 首次发布

本文链接：https://blog.youkuaiyun.com/const_/article/details/89497058

版权

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

14 篇文章

订阅专栏

文章目录

面试题：在多线程环境下，如何防止自己的变量被其它线程篡改
ThreadLocal 的作用
ThreadLocal 使用场景
演示 SimpleDateFormat 线程安全问题
ThreadLocal好处
ThreadLocal原理
ThreadLocal相关方法
ThreadLocal注意点
ThreadLocal封装的工具类

面试题：在多线程环境下，如何防止自己的变量被其它线程篡改

多线程情况下，类中的成员变量是多个线程共享的资源，如何保证共享资源的线程安全。
第一种思路是使用锁，锁表示同一时刻只有一个线程使用资源。
第二种思路是使用 ThreadLocal。

ThreadLocal 的作用

线程间数据隔离，填充的数据只属于当前线程，变量的数据对别的线程而言是相对隔离的。

ThreadLocal<String> localName = new ThreadLocal();
localName.set("张三");
String name = localName.get();
localName.remove();

ThreadLocal 使用场景

场景1：
每个线程需要一个独享对象（通常是工具类，典型需要使用的类有 SimpleDateFormat 、Random）。
每个Thread内有自己的实例副本，不共享。
比喻：教材只有一本，一起做笔记有线程安全问题。复印后没有问题，使用ThradLocal相当于复印了教材。

场景2：
项目中存在一个线程经常遇到横跨若干方法调用，需要传递的对象，也就是上下文（Context），它是一种状态，经常就是是用户身份、任务信息等，就会存在过渡传参的问题。给每个方法增加一个 context 参数非常麻烦，可以使用 ThreadLocal ，这样只需要在调用前在 ThreadLocal 中设置参数，其他地方 get 一下就好了。

演示 SimpleDateFormat 线程安全问题

// 1000个线程打印日期
public class SimpleDateFormatThreadSafeDemo {
    private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            new Thread(() -> {
                //参数的单位是毫秒，从1970.1.1 00:00:00 GMT 开始计时
                Date date = new Date(1000 * finalI);
                System.out.println(dateFormat.format(date));
            }, "Thread-1").start();
        }
    }
}

运行结果中出现了秒数相同的打印结果，出现了线程安全的问题。
在这里插入图片描述
出现问题的原因：
format 方法在执行过程中，会操作成员变量 calendar 来保存时间 calendar.setTime(date) ，因为 calendar 变量是一个共享变量。
假设线程 A 刚执行完 calendar.setTime(date) 语句，把时间设置为 2020-09-01，但线程还没执行完，线程 B 又执行了 calendar.setTime(date) 语句，把时间设置为 2020-09-02，这个时候线程 A 继续执行下去的时候，拿到的 calendar.getTime 得到的时间就是线程B改过之后的，出现线程安全问题。

// 成员变量 Calendar
protected Calendar calendar;

在这里插入图片描述
为了解决这个问题就是不要把 SimpleDateFormat 当做一个共享变量来使用。

解决问题的方案：
方案1：
每次使用就创建一个新的 SimpleDateFormat，会频繁地创建和销毁对象，效率较低。
方案2：
加锁，为格式化代码块添加synchronized锁。缺点是并发量大的时候会对性能有影响，因为使用了 synchronized 加锁后的多线程就相当于串行，线程阻塞，执行效率低。

Date date = new Date(1000 * finalI);
synchronized (SimpleDateFormatThreadSafeDemo.class) {
   	System.out.println(dateFormat.format(date));
}

方案3：
ThreadLocal 提供了线程本地的实例，它与普通变量的区别在于，每个使用该线程变量的线程都会初始化一个完全独立的实例副本。

// 1000个线程打印日期
public class SimpleDateFormatThreadLocalDemo {
    public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"));

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            new Thread(() -> {
                //参数的单位是毫秒，从1970.1.1 00:00:00 GMT 开始计时
                Date date = new Date(1000 * finalI);
                System.out.println(dateFormatThreadLocal.get().format(date));
            }, "Thread-1").start();
        }
    }
}

使用了ThreadLocal后不同的线程不会有共享的 SimpleDateFormat 对象，所以也就不会有线程安全问题。

注意：
为每一个线程分配不同的对象，并不是由ThreadLocal来完成的，需要在每个线程内部新建一个对象；
如果在应用上为每一个线程分配了相同的对象实例，ThreadLocal也不能保证线程安全，ThreadLocal只是一个简单的容器作用。

ThreadLocal好处

达到线程安全的目的
不需要加锁，执行效率高
更加节省内存，节省开销
免去传参的繁琐，降低代码耦合度

ThreadLocal原理

Thread 类定义了一个 ThreadLocal.ThreadLocalMap 静态内部类对象。
所以每个线程实例都有自己的 ThreadLocalMap。
ThreadLocalMap 可以理解为是一个 Map，所以 ThreadLocal 存储的是键值对数据。
在这里插入图片描述

ThreadLocal.java

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

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

在这里插入图片描述

ThreadLocal相关方法

T initialValue() ：
在这里插入图片描述
该方法用于设置初始值，并且在调用get()方法时才会被触发，所以是懒加载。
但是如果在get()之前进行了set()操作，这样就不会调用initialValue()。
通常每个线程只能调用一次本方法，但是调用了remove()后就能再次调用

// JDK8之前
public static ThreadLocal<Map<String, String>> threadLocal2 = new ThreadLocal<Map<String, String>>(){
    @Override
    protected Map initialValue() {
        return new HashMap<>();
    }
};
// JDK8之后添加了withInitial静态方法来进行初始化
public static ThreadLocal<Map<String, String>> threadLocal1 = ThreadLocal.withInitial(() -> new HashMap<>());

void set(T t)：
1、获取当前线程对象
2、通过 getMap 方法获取线程的 ThreadLocalMap
3、如果 ThreadLocalMap 为空，就创建一个新的，否则将值设置到 ThreadLocalMap 中
在这里插入图片描述

ThreadLocalMap 可以理解为一个Map（其实不是），是 ThreadLocal 中的一个内部类。

在 Thread 内部的定义了一个 ThreadLocalMap 类型的成员变量。
设置到 ThreadLocal 中的数据，也正是写入了 threadLocals 这个 Map中，key 为当前线程对象，value 就是写入的值。
在这里插入图片描述

ThreadLocal注意点

内存泄漏：
保存的对象数据是维护在Thread内部的，意味着只要线程不退出，对象的引用就一直存在。
当线程退出时，Thread类会进行清理工作，其中包括清理 ThreadLocalMap。
然而，如果使用线程池方式的话，意味着当前线程未必会退出，导致设置到 ThreadLocal 中的对象无法被回收，其实这个对象使用几次后不会再被使用了，但是又无法清理，可能会出现内存泄漏。
所以强烈建议在使用完一个 ThreadLoca 后，务必使用 ThreadLocal.remove() 将对象移除到。

共享对象问题：
如果在每个线程中ThreadLocal.set()进去的东西本来就是多个线程共享的同一对象，比如static对象，那么多个线程调用ThreadLocal.get()获取的内容还是同一个对象，还是会发生线程安全问题。

ThreadLocal封装的工具类

public class ThreadLocalUtil {

    /** 线程容器 **/
    private static ThreadLocal<Map<String, Object>> threadContext = new ThreadLocal<>();

    private ThreadLocalUtil() {}

    /**
     * 从ThreadLocal里获取值
     *
     * @param key 要获取的数据的KEY
     * @return 要获取的值
     */
    public static Object get(String key) {
        Map<String, Object> map = threadContext.get();
        Object value = null;
        if(!isThreadContextIsNull() && map.containsKey(key)) {
            value = map.get(key);
        }
        return value;
    }

    /**
     * 向ThreadLocal存放值
     *
     * @param key 要缓存的KEY
     * @param value 要缓存的VALUE
     */
    public static void put(String key, Object value) {
        if(!isThreadContextIsNull()){
            getContextMap().put(key, value);
        }
        else{
            Map<String, Object> map = new HashMap<>();
            map.put(key, value);
            threadContext.set(map);
        }
    }

    /**
     * 根据KEY移除缓存里的数据
     *
     * @param key
     * @return
     */
    public static void remove(String key) {
        if(!isThreadContextIsNull()) {
            getContextMap().remove(key);
        }
    }

    /**
     * 清理线程
     * 用于释放当前线程ThreadLocal资源
     */
    public static void clear() {
        threadContext.remove();
    }

    /**
     * 取得实例
     */
    private static Map<String, Object> getContextMap() {
        return (Map<String, Object>) threadContext.get();
    }

    /**
     * 判断线程容器中的Map是否为null
     */
    private static boolean isThreadContextIsNull(){
        return threadContext.get() == null;
    }

}

直接在当前线程任意方法里进行储存：

ThreadLocalUtil.put("name", "Tom");

当前线程里的任意方法里取值：

Object value = ThreadLocalUtil.get("name");

最后的时候需要进行清空，防止内存泄漏：

ThreadLocalUtil.clear();

参考：
为什么SimpleDateFormat不是线程安全的?
Java 面试必备：ThreadLocal 终极篇，助力你通关面试