ThreadLocal

最新推荐文章于 2024-07-15 15:40:07 发布

一僷知秋

最新推荐文章于 2024-07-15 15:40:07 发布

阅读量77

点赞数 1

文章标签： java 后端

本文链接：https://blog.csdn.net/qq_38258824/article/details/134049174

版权

一、认识ThreadLocal（看源码）

ThreadLocal提供线程局部变量。这些变量与普通对应变量的不同之处在于，访问一个变量的每个线程（通过其 {@code get} 或 {@code set} 方法）都有自己的独立初始化的变量副本。{@code ThreadLocal} 实例通常是希望将状态与线程（例如，用户 ID 或事务 ID）相关联的类中的私有静态字段。

例如，下面的类生成每个线程的本地唯一标识符。线程的 id 在第一次调用 {@code ThreadId.get（）} 时分配，并在后续调用中保持不变。

	import java.util.concurrent.atomic.AtomicInteger;

    public class ThreadId {
        // 包含要分配的下一个线程 ID 的原子整数
        private static final AtomicInteger nextId = new AtomicInteger(0);
        // 包含每个线程 ID 的线程局部变量
        private static final ThreadLocal<Integer> threadId =
                new ThreadLocal<Integer>() {
                    @Override
                    protected Integer initialValue() {
                        return nextId.getAndIncrement();
                    }
                };

        // 返回当前线程的唯一 ID，必要时分配它
        public static int get() {
            return threadId.get();
        }
    }

每个线程都持有对其线程局部变量副本的隐式引用，只要线程处于活动状态并且 {@code ThreadLocal} 实例可访问;线程消失后，其线程本地实例的所有副本都将受到垃圾回收（除非存在对这些副本的其他引用）。

ThreadLocal有四个常用的方法，分别是：

initialValue：

    /**
     * 为此线程局部变量返回当前线程的“初始值”。 
     * 此方法将在第一个调用
     * 线程访问变量的时间 {@link #get}
     * 方法，除非线程之前调用了 {@link #set}
     * 方法，在这种情况下，{@code initialValue} 方法不会
     * 为线程调用。 通常，此方法在
     * 每个线程最多一次，但在以下情况下可能会再次调用
     * 随后调用 {@link #remove}，后跟 {@link #get}。
     *
     * <p>此实现仅返回 {@code null};如果
     * 程序员希望线程局部变量有一个初始
     * 除 {@code null} 以外的值，{@code ThreadLocal} 必须是
     * 子类化，此方法被覆盖。 通常，一个
     * 将使用匿名内部类。
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

get：

    /**
     * 返回当前线程副本中的值
     * 线程局部变量。 如果变量没有
     * 当前线程，它首先初始化为返回的值
     * 通过调用 {@link #initialValue} 方法。
     *
     * @return the current thread's value of this thread-local
     */
    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();
    }

    /**
     * 设置此线程局部变量的当前线程副本
     * 到指定值。 大多数子类不需要
     * 覆盖此方法，仅依赖 {@link #initialValue}
     * 方法设置线程局部变量的值。
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

remove

    /**
     * 删除此线程本地的当前线程值
     * 变量。 如果此线程局部变量随后是
     * {@linkplain #get读取} 由当前线程读取，其值将为
     * 通过调用其 {@link #initialValue} 方法重新初始化，
     * 除非其值是当前线程的 {@linkplain #set set}
     * 在此期间。 这可能会导致多次调用
     * {@code 当前线程中的 initialValue} 方法。
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

二、ThreadLocalMap和ThreadLocal的关系

ThreadLocalMap 是一个自定义的哈希映射，仅适用于维护线程本地值。不会在 ThreadLocal 类外部导出任何操作。该类是包私有的，允许在类 Thread 中声明字段。为了帮助处理非常大且长期存在的用法，哈希表条目对键使用 WeakReferences（弱引用）。但是，由于不使用引用队列，因此仅当表开始空间不足时，才能保证删除过时的条目。

1.查看Thread类内部有两个变量，分别为threadLocals 和inheritableThreadLocals ，
类型均是ThreadLocal.ThreadLocalMap

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

2.上方set方法里的createMap，其内部是为了给Thread类里面的threadLocals 赋值，也就是初始化一个ThreadLocalMap对象。ThreadLocal作为key，需要存储的数据作为value。

    /**
     * 创建与 ThreadLocal 关联的映射. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

	//内部类
    static class ThreadLocalMap {

	     /**
         * 初始容量 - 必须是 2 的幂。
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 构造一个最初包含（firstKey，firstValue）的新映射。
         * ThreadLocalMaps 是懒惰构造的，所以我们只创建
         * 当我们至少有一个条目要放入时，一个。
         */
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
    }

3.关系图（有助理解）

在这里插入图片描述

三、ThreadLocal的常用场景

记录操作时间：结合AOP，before时set一个时间，after时获取这个时间并计算与当前时间的差值

    /** 计算操作消耗时间 */
    private static final ThreadLocal<Long> TIME_THREADLOCAL = new NamedThreadLocal<Long>("Cost Time");

	    /**
     * 处理请求前执行
     */
    @Before(value = "@annotation(controllerLog)")
    public void doBefore(JoinPoint joinPoint, Log controllerLog)
    {
        TIME_THREADLOCAL.set(System.currentTimeMillis());
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult)
    {
    	//消耗时间，毫秒
    	Long costTime = System.currentTimeMillis() - TIME_THREADLOCAL.get();
    }

用户登录后将登录信息存放在当前线程的ThreadLocal变量中，需要时随时取用，退出后销毁（与1类似）；
多数据情况下，保证所有操作在同一数据源下，处理数据库事务

public class DynamicDataSourceContextHolder
{
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源的变量
     */
    public static void setDataSourceType(String dsType)
    {
        log.info("切换到{}数据源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 获得数据源的变量
     */
    public static String getDataSourceType()
    {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 清空数据源变量
     */
    public static void clearDataSourceType()
    {
        CONTEXT_HOLDER.remove();
    }
}

/**
 * 多数据源处理
 * 
 */
@Aspect
@Order(1)
@Component
public class DataSourceAspect
{
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(xx.xx.xx.annotation.DataSource)"
            + "|| @within(xx.xx.xx.annotation.DataSource)")
    public void dsPointCut()
    {

    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable
    {
        DataSource dataSource = getDataSource(point);

        if (StringUtils.isNotNull(dataSource))
        {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }

        try
        {
            return point.proceed();
        }
        finally
        {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point)
    {
        MethodSignature signature = (MethodSignature) point.getSignature();
        DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
        if (Objects.nonNull(dataSource))
        {
            return dataSource;
        }

        return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
    }
}

/**
 * 自定义多数据源切换注解
 *
 * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
 *
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource
{
    /**
     * 切换数据源名称
     */
    public DataSourceType value() default DataSourceType.MASTER;
}

/**
 * 数据源
 * 
 */
public enum DataSourceType
{
    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE
}

解决spring下线程安全问题
举个栗子：

public class Foo
{
    // SimpleDateFormat is not thread-safe, so give one to each thread
    private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue()
        {
            return new SimpleDateFormat("yyyyMMdd HHmm");
        }
    };

    public String formatIt(Date date)
    {
        return formatter.get().format(date);
    }
}

后续使用到其他地方再补充…

参考：
https://stackoverflow.com/questions/817856/when-and-how-should-i-use-a-threadlocal-variable
https://docs.oracle.com/javase/8/docs/api/java/lang/ThreadLocal.html

一僷知秋

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal

这些变量与普通对应变量的不同之处在于，访问一个变量的每个线程（通过其 {@code get} 或 {@code set} 方法）都有自己的独立初始化的变量副本。{@code ThreadLocal} 实例通常是希望将状态与线程（例如，用户 ID 或事务 ID）相关联的类中的私有静态字段。线程消失后，其线程本地实例的所有副本都将受到垃圾回收（除非存在对这些副本的其他引用）。线程的 id 在第一次调用 {@code ThreadId.get（）} 时分配，并在后续调用中保持不变。后续使用到其他地方再补充…
复制链接

扫一扫