浅谈TheadLocal的使用场景和注意事项

概念

ThreadLocal 是Java的一个类，是一个本地线程，提供了一种线程安全的方式，主要用来避免共享数据（线程变量隔离）。

有时候可能要避免共享变量，使用ThreadLocal辅助类为各个线程提供各自的实例；就是说，每个线程都有一个伴生的空间(ThreadLocal)，存储私有的数据，只要线程在，就能拿到对应线程的ThreadLocal中存储的值。

TheadLocal的使用场景和注意事项

ThreadLocal在Java开发中非常常见，一般在以下情况会使用到ThreadLocal：

• 
  
• 在进行对象跨层传递的时候，可以考虑使用ThreadLocal，避免方法多次传递，打破层次间的约束。
  
• 线程间数据隔离，比如：上下文ActionContext、ApplicationContext。
  
• 进行事务处理，用于存储线程事务信息。
  

在使用ThreadLocal的时候，最常用的方法就是：initialValue()、set(T t)、get()、remove()。

创建以及提供的方法

创建一个线程局部变量，其初始值通过调用给定的提供者(Supplier)生成；

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {

        return new SuppliedThreadLocal<>(supplier);

    }


// InitialValue()初始化方式使用Java 8提供的Supplier函数接口会更加简介

ThreadLocal<String> userContext = ThreadLocal.withInitial(String::new);

这里就列出用的比较多的方法：

将此线程局部变量的当前线程副本设置为指定值；value表示要存储在此线程本地的当前线程副本中的值

public void set(T value) {

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null)

        map.set(this, value);

    else

        createMap(t, value);

}

返回此线程局部变量的当前线程副本中的值。 如果该变量对于当前线程没有值，则首先将其初始化为调用initialValue方法返回的值

public T get() {

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null) {

        ThreadLocalMap.Entry e = map.getEntry(this);

        if (e != null) {

            @SuppressWarnings("unchecked")

            T result = (T)e.value;

            return result;

        }

    }

    return setInitialValue();

}

删除此线程局部变量的当前线程值

public void remove() {

    ThreadLocalMap m = getMap(Thread.currentThread());

    if (m != null)

        m.remove(this);

}

项目实例

以下是个人使用的场景：

为什么会使用它，如果在项目中想直接获取当前登录用户的信息，这个功能就可以使用ThreadLocal实现。

/**

 * 登录用户信息上下文

 *

 * @author: austin

 * @since: 2023/2/8 13:47

 */

public class UserContext {


    private static final ThreadLocal<User> USER_CONTEXT = ThreadLocal.withInitial(User::new);


    public static void set(User user) {

        if (user != null) {

            USER_CONTEXT.set(user);

        }

    }


    public static User get() {

        return USER_CONTEXT.get();

    }


    public static void remove() {

        USER_CONTEXT.remove();

    }


    public static User getAndThrow() {

        User user = USER_CONTEXT.get();

        if (user == null || StringUtils.isEmpty(user.getId())) {

            throw new ValidationException("user info not found!");

        }

        return user;

    }

}

上面其实是定义了一个用户信息上下文类，关于上下文（context），我们在开发的过程中经常会遇到，比如Spring的ApplicationContext，上下文是贯穿整个系统或者阶段生命周期的对象，其中包含一些全局的信息，比如：登录后用户信息、账号信息、地址区域信息以及在程序的每一个阶段运行时的数据。

👏有了这个用户上下文对象之后，接下来就可以在项目中使用：

在该项目中个人使用的地方在登录拦截器中，当对登录的信息检查成功后，那么将当前的用户对象加入到ThreadLocal中：

User currentUser = userService.login(token.getUsername(), String.valueOf(token.getPassword()));

// 用户登录认证成功，UserContext存储用户信息

UserContext.put(currentUser);

在Serivce实现层使用的时候，直接调用ThreadLocal中的get方法，就可以获得当前登录用户的信息：

//获取当前在线用户信息

User user = UserContext.get();

资源调用完成后需要在拦截器中删除ThreadLocal资源，防止内存泄漏问题：

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    //使用完的用户信息需要删除，防止内存泄露

    UserContext.remove();

}

ThreadLocal的内存泄露问题🤢

如果我们在使用完该线程后不进行ThreadLocal中的变量进行删除，那么就会造成内存泄漏的问题，那么该问题是怎么出现的？

首先先分析一下ThreadLocal的内部结构：

先明确一个概念：对应在栈中保存的是对象的引用，对象的值是存储在堆中，如上图所示：其中Heap中的map是ThreadLocalMap, 里面包含key和value, 其中value就是我们需要保存的变量数据，key则是ThreadLocal实例，上述图片的连接有实线和虚线，实线代表强引用，虚线表示弱引用。

即：每一个Thread维护一个ThreadLocalMap, key为使用 弱引用 的ThreadLocal实例，value为线程变量的副本。

扫盲强引用、软引用、弱引用、虚引用：😂

不同的引用类型呢，主要体现在对象的不同的可达性状态和对垃圾收集的影响：

强引用 是Java最常见的一种引用，只要还有强引用指向一个对象，那么证明该对象一定还活着，一定为可达性状态，不会被垃圾回收机制回收，因此，强引用是造成Java内存泄漏的主要原因。

软引用 是通过SoftReference实现的，如果一个对象只要软引用，那么在系统内存空间不足的时候会试图回收该引用指向的对象。

弱引用 是通过WeakReference实现的，如何一个对象只有弱引用，在垃圾回收线程扫描它所管辖的内存区域的时候，一旦发现只有弱引用指向的对象时候，不管当前的内存空间是否足够，垃圾回收器都会去回收这样的一个内存。

虚引用 形同虚设的东西，在任何情况下都可能被回收。

我们都知道，map中的value需要key找到，key没了，那么value就会永远的留在内存中，直到内存满了，导致OOM，所以我们就需要使用完以后进行手动删除，这样能保证不会出现因为GC的原因造成的OOM问题；当ThreadLocal Ref显示的指定为null时，关系链就变成了下面所示的情况：

当ThreadLocal被显示显的指定为null之后，JVM执行GC操作，此时堆内存中的Thread-Local被回收，同时ThreadLocalMap中的Entry.key也成为了null，但是value将不会被释放，除非当前线程已经结束了生命周期的Thread引用被垃圾回收器回收。

ThreadLocal解决SimpleDateFormat非线程安全问题

为了找到问题所在，我们尝试查看SimpleDateFormat中format方法的源码来排查一下问题，format方法源码如下：

private StringBuffer format(Date date, StringBuffer toAppendTo,

                            FieldDelegate delegate) {


    // 注意到此行setTime()方法代码

    calendar.setTime(date);


    boolean useDateFormatSymbols = useDateFormatSymbols();


    for (int i = 0; i < compiledPattern.length; ) {

        int tag = compiledPattern[i] >>> 8;

        int count = compiledPattern[i++] & 0xff;

        if (count == 255) {

            count = compiledPattern[i++] << 16;

            count |= compiledPattern[i++];

        }


        switch (tag) {

        case TAG_QUOTE_ASCII_CHAR:

            toAppendTo.append((char)count);

            break;


        case TAG_QUOTE_CHARS:

            toAppendTo.append(compiledPattern, i, count);

            i += count;

            break;


        default:

            subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);

            break;

        }

    }

    return toAppendTo;

}

从上述源码可以看出，在执行SimpleDateFormat.format()方法时，会使用calendar.setTime()方法将输入的时间进行转换，那么我们想象一下这样的场景：

• 
  
• 线程 1 执行了calendar.setTime(date) 方法，将用户输入的时间转换成了后面格式化时所需要的时间；
  
• 线程 1 暂停执行，线程 2 得到CPU时间片开始执行；
  
• 线程 2 执行了calendar.setTime(date)方法，对时间进行了修改；
  
• 线程 2 暂停执行，线程 1 得出CPU时间片继续执行，因为线程 1 和线程 2 使用的是同一对象，而时间已经被线程 2 修改了，所以此时当线程 1 继续执行的时候就会出现线程安全的问题了。
  

正常情况下，程序执行是这样的：

非线程安全的执行流程是这样的：

了解了ThreadLocal的使用之后，我们回到本文的主题，接下来我们将使用ThreadLocal来实现100个时间的格式化，具体实现代码如下：

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;


/**

 * 多线程时间工具类：ConcurrentDateUtil

 * 

 * @author: austin

 * @since: 2023/2/8 15:36

 */

public class ConcurrentDateUtil {


    private static final String date_format = "yyyy-MM-dd HH:mm:ss";

    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();


    public static DateFormat getDateFormat() {

        DateFormat df = threadLocal.get();

        if (df == null) {

            df = new SimpleDateFormat(date_format);

            threadLocal.set(df);

        }

        return df;

    }


    public static String formatDate(Date date) throws ParseException {

        return getDateFormat().format(date);

    }


    public static Date parse(String strDate) throws ParseException {

        return getDateFormat().parse(strDate);

    }

}

当然也可以使用：

• 
  
• Apache commons包的DateFormatUtils或者FastDateFormat实现，宣称是既快又线程安全的SimpleDateFormat，并且更高效。
  
• 使用Joda-Time类库来处理时间相关问题。
  

总结

本文简单的介绍了ThreadLocal的应用场景，其主要用在需要每个线程独占的元素上，例如SimpleDateFormat。然后，就是介绍了ThreadLocal的实现原理，详细介绍了set()和get()方法，介绍了ThreadeLocalMap的数据结构，最后就是说到了ThreadLocal的内存泄露以及避免的方式。