通过ThreadLocal实现一个上下文管理组件

最新推荐文章于 2023-11-21 22:00:30 发布
最新推荐文章于 2023-11-21 22:00:30 发布
阅读量214 收藏
点赞数
分类专栏： ThreadLocal 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39687472/article/details/129217041
版权

背景

  • https://blog.csdn.net/qq_39687472/article/details/129213948
    上文中已经解析了ThreadLocal原理以及应用场景
  • 本文基于ThreadLocal原理，实现了一个上下文状态管理组件Scope，通过开启一个自定义的Scope，在Scope范围内，可以通过Scope各个方法读写数据；
  • 通过自定义线程池实现上下文状态数据的线程间传递；
  • 提出了一种基于Filter和Scope的Request粒度的上下文管理方案。

文章源码地址：
github：https://github.com/pengchengSU/demo-request-scope

自定义上下文Scope

在工作中，我们经常需要维护一些上下文，这样可以避免在方法调用过程中传入过多的参数，需要查询/修改一些数据的时候，直接在当前上下文中操作就行了。举个具体点的例子：当web服务器收到一个请求时，需要解析当前登录态的用户，在后续的业务执行流程中都需要这个用户名。

如果只需要维护一个上下文状态数据还比较好处理，可以通过方法传参的形式，执行每个业务方法的时候都通过添加一个表示用户名方法参数传递进去，但是如果需要维护上下文状态数据比较多的话，这个方式就不太优雅了。

一个可行的方案是通过Threadlocal实现请求线程的上下文，只要是同一线程的执行过程，不同方法间不传递上下文状态变量，直接操作ThreadLocal对象实现状态数据的读写。当存在多个上下文状态的话，则需要维护多个ThreadLocal，似乎也可以勉强接受。但是当遇到业务流程中使用线程池的情况下，从Tomcat传递这些ThreadLocal到线程池中的线程里就变的比较麻烦了。

基于以上考虑，下面介绍一种基于Threadlocal实现的上下文管理组件Scope：

Scope.java

public class Scope {

    // 静态变量，维护不同线程的上下文Scope
    private static final ThreadLocal<Scope> SCOPE_THREAD_LOCAL = new ThreadLocal<>();

    // 实例变量，维护每个上下文中所有的状态数据，为了区分不同的状态数据，使用ScopeKey类型的实例作为key
    private final ConcurrentMap<ScopeKey<?>, Object> values = new ConcurrentHashMap<>();

    // 获取当前上下文
    public static Scope getCurrentScope() {
        return SCOPE_THREAD_LOCAL.get();
    }

    // 在当前上下文设置一个状态数据
    public <T> void set(ScopeKey<T> key, T value) {
        if (value != null) {
            values.put(key, value);
        } else {
            values.remove(key);
        }
    }

    // 在当前上下文读取一个状态数据
    public <T> T get(ScopeKey<T> key) {
        T value = (T) values.get(key);
        if (value == null && key.initializer() != null) {
            value = key.initializer().get();
        }
        return value;
    }

    // 开启一个上下文
    public static Scope beginScope() {
        Scope scope = SCOPE_THREAD_LOCAL.get();
        if (scope != null) {
            throw new IllegalStateException("start a scope in an exist scope.");
        }
        scope = new Scope();
        SCOPE_THREAD_LOCAL.set(scope);
        return scope;
    }

    // 关闭当前上下文
    public static void endScope() {
        SCOPE_THREAD_LOCAL.remove();
    }
}

ScopeKey.java

public final class ScopeKey<T> {

    // 初始化器，参考 ThreadLocal 的 withInitial()
    private final Supplier<T> initializer;

    public ScopeKey() {
        this(null);
    }

    public ScopeKey(Supplier<T> initializer) {
        this.initializer = initializer;
    }

    // 统一初始化所有线程的 ScopeKey 对应的值，参考 ThreadLocal 的 withInitial()
    public static <T> ScopeKey<T> withInitial(Supplier<T> initializer) {
        return new ScopeKey<>(initializer);
    }

    public Supplier<T> initializer() {
        return this.initializer;
    }

    // 获取当前上下文中 ScopeKey 对应的变量
    public T get() {
        Scope currentScope = getCurrentScope();
        return currentScope.get(this);
    }

    // 设置当前上下文中 ScopeKey 对应的变量
    public boolean set(T value) {
        Scope currentScope = getCurrentScope();
        if (currentScope != null) {
            currentScope.set(this, value);
            return true;
        } else {
            return false;
        }
    }
}

使用方式

@Test
public void testScopeKey() {
    ScopeKey<String> localThreadName = new ScopeKey<>();

    // 不同线程中执行时，开启独占的 Scope
    Runnable r = () -> {
        // 开启 Scope
        Scope.beginScope();
        try {
            String currentThreadName = Thread.currentThread().getName();
            localThreadName.set(currentThreadName);
            log.info("currentThread: {}", localThreadName.get());
        } finally {
            // 关闭 Scope
            Scope.endScope();
        }
    };

    new Thread(r, "thread-1").start();
    new Thread(r, "thread-2").start();

    /** 执行结果
     * [thread-1] INFO com.example.demo.testscope.TestScope - currentThread: thread-1
     * [thread-2] INFO com.example.demo.testscope.TestScope - currentThread: thread-2
     */
}

@Test
public void testWithInitial() {
    ScopeKey<String> initValue = ScopeKey.withInitial(() -> "initVal");

    Runnable r = () -> {
        Scope.beginScope();
        try {
            log.info("initValue: {}", initValue.get());
        } finally {
            Scope.endScope();
        }
    };

    new Thread(r, "thread-1").start();
    new Thread(r, "thread-2").start();

    /** 执行结果
     * [thread-1] INFO com.example.demo.testscope.TestScope - initValue: initVal
     * [thread-2] INFO com.example.demo.testscope.TestScope - initValue: initVal
     */
}

上面的测试用例中在代码中手动开启和关闭Scope不太优雅，可以在Scope中添加两个静态方法包装下Runnable和Supplier接口：

//开启一个新的 Scope 执行 Runnable
public static <X extends Throwable> void runWithNewScope(@Nonnull ThrowableRunnable<X> runnable)
        throws X {
    supplyWithNewScope(() -> {
        runnable.run();
        return null;
    });
}

//开启一个新的 Scope 执行 Supplier
public static <T, X extends Throwable> T
        supplyWithNewScope(@Nonnull ThrowableSupplier<T, X> supplier) throws X {
    beginScope();
    try {
        return supplier.get();
    } finally {
        endScope();
    }
}

两个接口

@FunctionalInterface
public interface ThrowableRunnable<X extends Throwable> {
    void run() throws X;
}

@FunctionalInterface
public interface ThrowableSupplier<T, X extends Throwable> {
    T get() throws X;
}

以新的Scope执行，可以这样写：

@Test
public void testRunWithNewScope() {
    ScopeKey<String> localThreadName = new ScopeKey<>();

    ThrowableRunnable r = () -> {
        String currentThreadName = Thread.currentThread().getName();
        localThreadName.set(currentThreadName);
        log.info("currentThread: {}", localThreadName.get());
    };

    // 不同线程中执行时，开启独占的 Scope
    new Thread(() -> Scope.runWithNewScope(r), "thread-1").start();
    new Thread(() -> Scope.runWithNewScope(r), "thread-2").start();

    /** 执行结果
     * [thread-2] INFO com.example.demo.TestScope.testscope - currentThread: thread-2
     * [thread-1] INFO com.example.demo.TestScope.testscope - currentThread: thread-1
     */
}

在线程池中传递Scope

在上一节中实现的Scope，通过ThreadLocal实现了了一个自定义的上下文组件，在同一个线程中通过ScopeKey.set() / ScopeKey.get()读写同一个上下文中的状态数据。

现在需要实现这样一个功能，在一个线程执行过程中开启了一个Scope，随后使用线程池执行任务，要求在线程池中也能获取当前Scope中的状态数据。典型的使用场景是：服务收到一个用户请求，通过Scope将登陆态数据存到当前线程的上下文中，随后使用线程池执行一些耗时的操作，希望线程池中的线程也能拿到Scope中的登陆态数据。
由于线程池中的线程和请求线程不是一个线程，按照目前的实现，线程池中的线程是无法拿到请求线程上下文中的数据的。
解决方法是，在提交runnable时，将当前的Scope引用存到runnable对象中，当获得线程执行时，将Scope替换到执行线程中，执行完成后，再恢复现场。在Scope中新增如下静态方法：

// 以给定的上下文执行 Runnable
public static <X extends Throwable> void runWithExistScope(Scope scope, ThrowableRunnable<X> runnable) throws X {
    supplyWithExistScope(scope, () -> {
        runnable.run();
        return null;
    });
}

// 以给定的上下文执行 Supplier
public static <T, X extends Throwable> T supplyWithExistScope(Scope scope, ThrowableSupplier<T, X> supplier) throws X {
    // 保留现场
    Scope oldScope = SCOPE_THREAD_LOCAL.get();
    // 替换成外部传入的 Scope
    SCOPE_THREAD_LOCAL.set(scope);
    try {
        return supplier.get();
    } finally {
        if (oldScope != null) {
            // 恢复线程
            SCOPE_THREAD_LOCAL.set(oldScope);
        } else {
            SCOPE_THREAD_LOCAL.remove();
        }
    }
}

实现支持Scope切换的自定义线程池ScopeThreadPoolExecutor：

public class ScopeThreadPoolExecutor extends ThreadPoolExecutor {

    ScopeThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                            TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public static ScopeThreadPoolExecutor newFixedThreadPool(int nThreads) {
        return new ScopeThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
    }

    /**
     * 只要override这一个方法就可以
     * 所有submit, invokeAll等方法都会代理到这里来
     */
    @Override
    public void execute(Runnable command) {
        Scope scope = getCurrentScope();
        // 提交任务时，把执行 execute 方法的线程中的 Scope 传进去
        super.execute(() -> runWithExistScope(scope, command::run));
    }
}

测试下ScopeThreadPoolExecutor是否生效：

@Test
public void testScopeThreadPoolExecutor() {
    ScopeKey<String> localVariable = new ScopeKey<>();
    Scope.beginScope();

    try {
        localVariable.set("value out of thread pool");
        Runnable r = () -> log.info("localVariable in thread pool: {}", localVariable.get());

        // 使用线程池执行，能获取到外部Scope中的数据
        ExecutorService executor = ScopeThreadPoolExecutor.newFixedThreadPool(10);
        executor.execute(r);
        executor.submit(r);

    } finally {
        Scope.endScope();
    }

    /** 执行结果
     * [pool-1-thread-1] INFO com.example.demo.testscope.TestScope - localVariable in thread pool: value out of thread pool
     * [pool-1-thread-2] INFO com.example.demo.testscope.TestScope - localVariable in thread pool: value out of thread pool
     */
}

@Test
public void testScopeThreadPoolExecutor2() {
    ScopeKey<String> localVariable = new ScopeKey<>();
    Scope.runWithNewScope(() -> {
        localVariable.set("value out of thread pool");
        Runnable r = () -> log.info("localVariable in thread pool: {}", localVariable.get());

        // 使用线程池执行，能获取到外部Scope中的数据
        ExecutorService executor = ScopeThreadPoolExecutor.newFixedThreadPool(10);
        executor.execute(r);
        executor.submit(r);
    });

    /** 执行结果
     * [pool-1-thread-2] INFO com.example.demo.testscope.TestScope - localVariable in thread pool: value out of thread pool
     * [pool-1-thread-1] INFO com.example.demo.testscope.TestScope - localVariable in thread pool: value out of thread pool
     */
}

以上两个测试用例，分别通过手动开启Scope、借助runWithNewScope工具方法自动开启Scope两种方式验证了自定义线程池ScopeThreadPoolExecutor的Scope可传递性。

通过Filter、Scope实现Request上下文

接下来介绍如何通过Filter和Scope实现Request粒度的Scope上下文。思路是：通过注入一个拦截器，在进入拦截器后开启Scope作为一个请求的上下文，解析Request对象获取获取相关状态信息(如登陆用户)，并在Scope中设置，在离开拦截器时关闭Scope。

AuthScope.java

// 获取登录态的工具类
public class AuthScope {
    private static final ScopeKey<String> LOGIN_USER = new ScopeKey<>();

    public static String getLoginUser() {
        return LOGIN_USER.get();
    }

    public static void setLoginUser(String loginUser) {
        if (loginUser == null) {
            loginUser = "unknownUser";
        }
        LOGIN_USER.set(loginUser);
    }
}

ScopeFilter.java

@Lazy
@Order(0)
@Service("scopeFilter")
public class ScopeFilter extends OncePerRequestFilter {

    @Override
    protected String getAlreadyFilteredAttributeName() {
        return this.getClass().getName();
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        // 开启Scope
        beginScope();
        try {
            Cookie[] cookies = request.getCookies();
            String loginUser = "unknownUser";
            if (cookies != null) {
                for (Cookie cookie : cookies) {
                    if (cookie.getName().equals("login_user")) {
                        loginUser = cookie.getValue();
                        break;
                    }
                }
            }

            // 设置该 Request 上下文对用的登陆用户
            AuthScope.setLoginUser(loginUser);

            filterChain.doFilter(request, response);
        } finally {
            // 关闭Scope
            endScope();
        }
    }
}

注入Filter

@Slf4j
@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<ScopeFilter> scopeFilterRegistration() {
        FilterRegistrationBean<ScopeFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new ScopeFilter());
        registration.addUrlPatterns("/rest/*");
        registration.setOrder(0);
        log.info("scope filter registered");
        return registration;
    }
}

UserController.java

@Slf4j
@RestController
@RequestMapping("/rest")
public class UserController {

    // curl --location --request GET 'localhost:8080/rest/getLoginUser' --header 'Cookie: login_user=zhangsan'
    @GetMapping("/getLoginUser")
    public String getLoginUser() {
        return AuthScope.getLoginUser();
    }

    // curl --location --request GET 'localhost:8080/rest/getLoginUserInThreadPool' --header 'Cookie: login_user=zhangsan'
    @GetMapping("/getLoginUserInThreadPool")
    public String getLoginUserInThreadPool() {
        ScopeThreadPoolExecutor executor = ScopeThreadPoolExecutor.newFixedThreadPool(4);
        executor.execute(() -> {
            log.info("get login user in thread pool: {}", AuthScope.getLoginUser());
        });

        return AuthScope.getLoginUser();
    }
}

通过以下请求验证，请求线程和线程池线程是否能获取登录态，其中登录态通过Cookie模拟：

curl --location --request GET 'localhost:8080/rest/getLoginUser' --header 'Cookie: login_user=zhangsan'
curl --location --request GET 'localhost:8080/rest/getLoginUserInThreadPool' --header 'Cookie: login_user=zhangsan'

感谢阅读，希望对你有所帮助 😃

敬请期待我的下一篇文章，谢谢。
在这里插入图片描述

来源：juejin.cn/post/7153287656624324638

码出。。。人生
关注
专栏目录
全链路跟踪之线程上下文Thread Local实战（完整源码）
猿码天地
07-22 1824
一、背景 ThreadLocal是JDK默认提供的本地线程变量，用来存储在整个调用链中都需要访问的数据，并且是线程安全的。由于本文的写作背景是笔者需要在公司落地全链路跟踪平台，一个基本并核心的功能需求是用户的每个操作动作需要在整个调用链中进行埋点传递，线程上下文环境成为解决这个问题最合适的技术。 二、ThreadLocal解决什么问题？ ThreadLocal是在Thread类之外实现的一个功能（java.lang.ThreadLocal）， 但它会为每个线程分别存储一份唯一的数据。正如它的名字所说的，它
线程上下文ThreadLocal
BASK2311的博客
01-09 443
作用？在同一个线程内，可以传递数据。什么意思呢？就是一个请求进来的时候，系统内是要经过很多个类和很多个方法的，那怎么在多个类和多个方法之间传递数据呢？靠ThreadLocal。然后这个对象threadLocal，存储了所有请求线程的数据。也就是说，你在不同地方读数据的时候，只要是同一个线程，那么读出来的数据就是同一个数据。这样就实现了在同一个线程内部的不同处理环节传递数据的作用。说白了，就是map。只不过键值对特殊一点，key是某个线程对象，value是数据。
ThreadLocal线程上下文
Engure
09-02 610
ThreadLocal ThreadLocal 本地线程变量，主要用于解决数据访问的竞争，通常用于多租户、全链路压测、链路跟踪中保存 线程上下文环境，在一个请求流转中非常方便的获取一些关键信息，例如当前的租户信息、压测标记。 ThreadLocal 正如其名，本地线程变量，即数据存储在线程自己的局部变量中。 其整体架构如下图所示： ThreadLocal的核心设计理念总结如下： 每一个线程对象会维护一个私有属性：ThreadLocal.ThreadLocalMap threadLocals
高并发编程(ThreadLocal)上下文设计模式
森林中的乌啦博客
11-03 399
ThreadLocal介绍: ThreadLocal类顾名思义可以理解为线程本地变量。也就是说如果定义了一个ThreadLocal，每个线程往这个ThreadLocal中读写是线程隔离，互相之间不会影响的。它提供了一种将可变数据通过每个线程有自己的独立副本从而实现线程封闭的机制。 上下文设计模式简介: 上下文就是贯穿整个系统或者阶段生命周期的对象，其中存贮了一些系统的全局变量信息。在很多时候，单个线程的执行任务步骤非常多的时候，后面的某一步骤需要前面的输出值（责任链模式中特别多），那么需要将参数从头传
09ThreadLocal在上下文中的应用
冷炎嗄的博客
09-06 415
ThreadLocal存储的内容在当前线程自己的ThreadLocalMap中，当线程销毁，数据自然被释放 实现一个简单的线程上下文 每个线程若想使用，直接使用get()获取对应的实例，然后调用相应的方法就行，不会影响其他线程调用实例  ...
线程池如何传递线程上下文信息
luoxn28的专栏
03-13 5120
戳蓝字「TopCoder」关注我们哦！业务开发中，一般都会使用ThreadLocal保存一些上下文信息，但是在线程池中执行对应逻辑时，由于是不同线程所...
Java 多线程上下文传递在复杂场景下的实践
m0_67698950的博客
07-03 785
海外商城从印度做起，慢慢地会有一些其他国家的诉求，这个时候需要我们针对当前的商城做一个改造，可以支撑多个国家的商城，这里会涉及多个问题，多语言，多国家，多时区，本地化等等。在多国家的情况下如何把识别出来的国家信息传递下去，一层一层直到代码执行的最后一步。甚至还有一些多线程的场景需要处理。ThreadLocal是最容易想到了，入口识别到国家信息后，丢进ThreadLocal，这样后续代码、redis、DB等做国家区分的时候都能使用到。这里先简单介绍一下ThreadLocal： 每一个Thread线程都
SecurityContextHolder实现原理（策略模式和ThreadLocal）
CTPeng的博客
12-04 3911
SecurityContextHolder实现原理一、核心组件1.1 SecurityContextHolder1.2 SecurityContextHolderStrategy1.3ThreadLocalSecurityContextHolderStrategy二、ThreadLocal源码分析1.1实现该功能的核心技术1.2ThreadLocal总结总结 SecurityContextHolder是SpringSecurity中保存认证信息的核心组件，重点是将给定的认证信息(SecurityConte
Quartz-ThreadLocal.rar
11-14
ThreadLocal 是 Java 中的一个重要工具类，用于在多线程环境中为每个线程维护独立的变量副本。这个压缩包 "Quartz-ThreadLocal.rar" 内含的学习资源很可能是关于如何在 Quartz 调度器中结合使用 ThreadLocal 的示例...
ThreadLocal和线程上下文-入门
weixin_42962086的博客
01-10 694
ThreadLocal和线程上下文 经过学习和理解，总结了以下经验： 真正的主角是线程上下文，而不是ThreadLocal ThreadLocal的本质是实现Java线程私有map变量的一个工具类，所以，提供的最核心的方法就是set和get 如果引入线程上下文的概念，那么，ThreadLocal就是实现线程上下文功能的工具类 摘要 本文主要的目的是实现ThreadLocal的入门，基于自己的理解给出一个比较容易懂的ThreadLocal定义，并且结合线程上下文的概念，给出ThreadLocal的定位。本
WeakReference在ThreadLocal中的使用
abcwywht的博客
04-01 422
1.ThreadLocal定义&作用 定义： ThreadLocal叫做线程本地变量，顾名思义，就是Thread的一个内部变量，这个ThreadLocal是属于某个线程的。就好比是某个人的老婆（们），老婆只能属于某个人，而不能被共享；这里老婆有可能是复数，一个人可以有多个老婆（好比在古代），老婆跟着丈夫走，丈夫生而生，丈夫死而死； 作用： 既然是属于某一个线程的变量，那么肯定就不是被多个线程共享的；这个东西在多线程场景中使用，目的就是防止变量在多个线程中游走，产生线程安全的问题。 下面描述一个
ThreadLocal(三) 线程上下文实战
weixin_38399962的博客
06-16 749
场景: 某个复杂长链路请求, 例如下单, 需要多组件方法参与,但是对于各种参数聚合, 耦合度很高对于二次开发不方便 解决思路: 利用 ThreadLocal 线程变量来完成, 以后每次改造只需要改造,或者向 ThreadLocal 中增加自己的参数即可, 注意: 禁止参与多线程!!!否则会导致参数丢失!!!!! 注意每个线程必须执行 destroy 操作!!! 建议在入口处进行线程变量初始化和销毁 1. 创建业务上下文类 package net.xinhuamm.converge.model.
多线程设计模式-Servlet上下文模式（Threadlocal实现）
qq_27552579的博客
01-03 425
上下文模式（Threadlocal实现） 在web中碰到运行上下文内容，可以用threadlocal的原理来实现，通过这种方式，更能明白网络请求中的上下文是如何实现的 使用场景：网络请求的数据分别在DB和其他http中，通过threadlocal隔离其他线程的访问本线程的内容，达到多线程安全的目的 上下文内容属性 package com.ln.concurrent.chapter11; /** * @ProjectName: java-concurrency * @Package: com.ln.co
通过ThreadLocal和Filter实现请求上下文【更新】
yh_zeng2的博客
06-25 4248
场景1：使用Spring的AOP面向切面编程，很多人都是为了给某个模块动态地添加功能。肯定会新增个做切面（Aspect）的类，这个类是个普通的Spring bean，这个Aspect怎么获取request、session对象呢？   场景2：在Service中，怎么获取当前登录用户信息？            很多人都会想到，在用户登陆的时候，将用户信息存到session中。Action层将
ThreadLocal 线程范围内的共享变量
飞腾创客
12-08 276
package cn.itcast.heima2; import java.util.HashMap; import java.util.Map; import java.util.Random;    //线程范围内的共享变量 public class ThreadLocalTest {           private static ThreadLocal&lt;Integer&gt; x...
ThreadLocal在多线程中的应用
john_cena的博客
05-23 133
  本例充分演示了ThreadLocal在多线程环境下，与线程绑定后的数据操作是完全隔离的！ 放心使用ThreadLocal吧！千万记得用完之后要remove!     package thread; import java.util.Date; import java.util.Random; /** * 线程范围内的变量，每个线程都有自己的一份数据，换不干扰 ...
ThreadLocal不香了？ScopedValue才是王道？
最新发布
Java精选
11-21 199
ThreadLocal是一种实现将变量在各线程之间隔离的方案，也叫线程局部变量表。在Java中每个线程都拥有一个ThreadLocal下的ThreadLocalMap类型的变量，它用来存储定义在线程中的ThreadLocal对象，ThreadLocalMap的键是一个弱引用，指向对应的ThreadLocal对象。但值得每一位Java开发者注意的是ThreadLocal变量如果不及时remove()...
Spring异步线程池—传递线程上下文(TaskDecorator实现)
weixin_45069056的博客
11-22 1893
Spring异步线程池—传递线程上下文(TaskDecorator实现)
框架用ThreadLocal
08-17
很多框架在实现线程安全的时候会使用 ThreadLocal 来管理线程的上下文信息或者共享变量。下面是一些框架中 ThreadLocal 的应用示例： 1. Spring 框架：在 Spring 中，使用 ThreadLocal 来管理事务上下文信息。通过 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值