别再用ThreadLocal了,ScopedValue更香!

从ThreadLocal到ScopedValue:线程池上下文串号怎么破? 线程局部变量(ThreadLocal)是Java中实现线程间数据隔离的经典手段,常用于传递traceId、用户身份等上下文信息。但其值生命周期与线程强绑定,在线程池复用场景下易出现脏数据串绕、链路追踪错乱等问题。为了从机制上补齐这一缺陷,ScopedValue被引入,核心设计是让绑定值随当前动态作用域生效、自动恢复,并支持结构化并发下的子任务继承。相比ThreadLocal,它在不可变性、可维护性和内存安全方面具备明显优势,更适合在新项目中承载链路追踪和请求级上下文。不过,从ThreadLocal迁移到Sc 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

👉这是一个或许对你有用的开源项目

国产Star破10w的开源项目,前端包括管理后台、微信小程序,后端支持单体、微服务架构

RBAC权限、数据权限、SaaS多租户、商城、支付、工作流、大屏报表、ERP、CRM、AI大模型、IoT物联网等功能:

  • 多模块:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 微服务:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK17/21+SpringBoot3、JDK8/11+Spring Boot2双版本 

来源:苏三说技术


前言

今天我们来聊聊一个即将改变我们编程习惯的新特性——ScopedValue。

有些小伙伴在工作中,一提到线程内数据传递就想到ThreadLocal,但真正用起来却遇到各种坑:内存泄漏、数据污染、性能问题等等。

其实,ScopedValue就像ThreadLocal的升级版,既保留了优点,又解决了痛点。

我们一起聊聊ScopedValue的优势和用法,希望对你会有所帮助。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

一、ThreadLocal的痛点

在介绍ScopedValue之前,我们先回顾一下ThreadLocal的常见问题。

有些小伙伴可能会想:"ThreadLocal用得好好的,为什么要换?"

其实,ThreadLocal在设计上存在一些固有缺陷。

ThreadLocal的内存泄漏问题

为了更直观地理解ThreadLocal的内存泄漏问题,我画了一个内存泄漏的示意图:

ThreadLocal的典型问题代码

/**
 * ThreadLocal典型问题演示
 */
publicclass ThreadLocalProblems {
    
    privatestaticfinal ThreadLocal<UserContext> userContext = new ThreadLocal<>();
    privatestaticfinal ThreadLocal<Connection> connectionHolder = new ThreadLocal<>();
    
    /**
     * 问题1:内存泄漏 - 忘记调用remove()
     */
    public void processRequest(HttpServletRequest request) {
        // 设置用户上下文
        UserContext context = new UserContext(request.getHeader("X-User-Id"));
        userContext.set(context);
        
        try {
            // 业务处理
            businessService.process();
            
            // 问题:忘记调用 userContext.remove()
            // 在线程池中,这个线程被重用时,还会保留之前的用户信息
        } catch (Exception e) {
            // 异常处理
        }
    }
    
    /**
     * 问题2:数据污染 - 线程复用导致数据混乱
     */
    public void processMultipleRequests() {
        // 线程池处理多个请求
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            finalint userId = i;
            executor.submit(() -> {
                // 设置用户上下文
                userContext.set(new UserContext("user_" + userId));
                
                try {
                    // 模拟业务处理
                    Thread.sleep(100);
                    
                    // 问题:如果线程被复用,这里可能读取到错误的用户信息
                    String currentUser = userContext.get().getUserId();
                    System.out.println("处理用户: " + currentUser);
                    
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    // 即使调用remove,也可能因为异常跳过
                    userContext.remove(); // 不保证一定执行
                }
            });
        }
        
        executor.shutdown();
    }
    
    /**
     * 问题3:继承性问题 - 子线程无法继承父线程数据
     */
    public void parentChildThreadProblem() {
        userContext.set(new UserContext("parent_user"));
        
        Thread childThread = new Thread(() -> {
            // 这里获取不到父线程的ThreadLocal值
            UserContext context = userContext.get(); // null
            System.out.println("子线程用户: " + context); // 输出null
            
            // 需要手动传递数据
        });
        
        childThread.start();
    }
    
    /**
     * 问题4:性能问题 - 大量ThreadLocal影响性能
     */
    public void performanceProblem() {
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < 100000; i++) {
            ThreadLocal<String> tl = new ThreadLocal<>();
            tl.set("value_" + i);
            String value = tl.get();
            tl.remove();
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("ThreadLocal操作耗时: " + (endTime - startTime) + "ms");
    }
}

/**
 * 用户上下文
 */
class UserContext {
    privatefinal String userId;
    privatefinallong timestamp;
    
    public UserContext(String userId) {
        this.userId = userId;
        this.timestamp = System.currentTimeMillis();
    }
    
    public String getUserId() {
        return userId;
    }
    
    public long getTimestamp() {
        return timestamp;
    }
    
    @Override
    public String toString() {
        return"UserContext{userId='" + userId + "', timestamp=" + timestamp + "}";
    }
}

ThreadLocal问题的根本原因

  1. 生命周期管理复杂 :需要手动调用set/remove,容易遗漏

  2. 内存泄漏风险 :线程池中线程复用,Value无法被GC

  3. 继承性差 :子线程无法自动继承父线程数据

  4. 性能开销 :ThreadLocalMap的哈希表操作有开销

有些小伙伴可能会问:"我们用InheritableThreadLocal不就能解决继承问题了吗?"

我的经验是:InheritableThreadLocal只是缓解了问题,但带来了新的复杂度,而且性能更差 。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

二、ScopedValue:新一代线程局部变量

ScopedValue是Java 20中引入的预览特性,在Java 21中成为正式特性。

它旨在解决ThreadLocal的痛点,提供更安全、更高效的线程内数据传递方案。

ScopedValue的核心设计理念

为了更直观地理解ScopedValue的工作原理,我画了一个ScopedValue的架构图:

ScopedValue的核心优势:

ScopedValue基础用法

/**
 * ScopedValue基础用法演示
 */
publicclass ScopedValueBasics {
    
    // 1. 定义ScopedValue(相当于ThreadLocal)
    privatestaticfinal ScopedValue<UserContext> USER_CONTEXT = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<Connection> DB_CONNECTION = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();
    
    /**
     * 基础用法:在作用域内使用ScopedValue
     */
    public void basicUsage() {
        UserContext user = new UserContext("user_123");
        
        // 在作用域内绑定值
        ScopedValue.runWhere(USER_CONTEXT, user, () -> {
            // 在这个作用域内,USER_CONTEXT.get()返回user_123
            System.out.println("当前用户: " + USER_CONTEXT.get().getUserId());
            
            // 可以嵌套使用
            ScopedValue.runWhere(REQUEST_ID, "req_456", () -> {
                System.out.println("请求ID: " + REQUEST_ID.get());
                System.out.println("用户: " + USER_CONTEXT.get().getUserId());
            });
            
            // 这里REQUEST_ID已经超出作用域,获取会抛出异常
        });
        
        // 这里USER_CONTEXT已经超出作用域
    }
    
    /**
     * 带返回值的作用域
     */
    public String scopedValueWithReturn() {
        UserContext user = new UserContext("user_789");
        
        // 使用callWhere获取返回值
        String result = ScopedValue.callWhere(USER_CONTEXT, user, () -> {
            // 业务处理
            String userId = USER_CONTEXT.get().getUserId();
            return"处理用户: " + userId;
        });
        
        return result;
    }
    
    /**
     * 多个ScopedValue同时使用
     */
    public void multipleScopedValues() {
        UserContext user = new UserContext("user_multi");
        Connection conn = createConnection();
        
        // 同时绑定多个ScopedValue
        ScopedValue.runWhere(
            ScopedValue.where(USER_CONTEXT, user)
                      .where(DB_CONNECTION, conn)
                      .where(REQUEST_ID, "multi_req"),
            () -> {
                // 在这个作用域内可以访问所有绑定的值
                processBusinessLogic();
            }
        );
        
        // 作用域结束后自动清理
    }
    
    /**
     * 异常处理示例
     */
    public void exceptionHandling() {
        UserContext user = new UserContext("user_exception");
        
        try {
            ScopedValue.runWhere(USER_CONTEXT, user, () -> {
                // 业务处理
                processBusinessLogic();
                
                // 如果抛出异常,作用域也会正常结束
                if (someCondition()) {
                    thrownew RuntimeException("业务异常");
                }
            });
        } catch (RuntimeException e) {
            // 异常处理
            System.out.println("捕获异常: " + e.getMessage());
        }
        
        // 即使发生异常,USER_CONTEXT也会自动清理
    }
    
    private Connection createConnection() {
        // 创建数据库连接
        returnnull;
    }
    
    private void processBusinessLogic() {
        // 业务逻辑处理
        UserContext user = USER_CONTEXT.get();
        System.out.println("处理业务逻辑,用户: " + user.getUserId());
    }
    
    private boolean someCondition() {
        return Math.random() > 0.5;
    }
}

三、ScopedValue vs ThreadLocal:全面对比

有些小伙伴可能还想知道ScopedValue到底比ThreadLocal强在哪里。

让我们通过详细的对比来看看。

3.1 内存管理对比

为了更直观地理解两者的内存管理差异,我画了几张图做对比。

ThreadLocal的内存模型图:

ScopedValue的内存模型图:

二者的关键差异如下图:

3.2 代码对比示例

/**
 * ThreadLocal vs ScopedValue 对比演示
 */
publicclass ThreadLocalVsScopedValue {
    
    // ThreadLocal方式
    privatestaticfinal ThreadLocal<UserContext> TL_USER_CONTEXT = new ThreadLocal<>();
    privatestaticfinal ThreadLocal<Connection> TL_CONNECTION = new ThreadLocal<>();
    
    // ScopedValue方式
    privatestaticfinal ScopedValue<UserContext> SV_USER_CONTEXT = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<Connection> SV_CONNECTION = ScopedValue.newInstance();
    
    /**
     * ThreadLocal方式 - 传统实现
     */
    public void processRequestThreadLocal(HttpServletRequest request) {
        // 设置上下文
        UserContext userContext = new UserContext(request.getHeader("X-User-Id"));
        TL_USER_CONTEXT.set(userContext);
        
        Connection conn = null;
        try {
            // 获取数据库连接
            conn = dataSource.getConnection();
            TL_CONNECTION.set(conn);
            
            // 业务处理
            processBusinessLogic();
            
        } catch (SQLException e) {
            // 异常处理
            handleException(e);
        } finally {
            // 必须手动清理 - 容易忘记!
            TL_USER_CONTEXT.remove();
            TL_CONNECTION.remove();
            
            // 关闭连接
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    // 日志记录
                }
            }
        }
    }
    
    /**
     * ScopedValue方式 - 现代实现
     */
    public void processRequestScopedValue(HttpServletRequest request) {
        UserContext userContext = new UserContext(request.getHeader("X-User-Id"));
        
        // 使用try-with-resources管理连接
        try (Connection conn = dataSource.getConnection()) {
            
            // 在作用域内执行,自动管理生命周期
            ScopedValue.runWhere(
                ScopedValue.where(SV_USER_CONTEXT, userContext)
                          .where(SV_CONNECTION, conn),
                () -> {
                    // 业务处理
                    processBusinessLogic();
                }
            );
            
            // 作用域结束后自动清理,无需手动remove
        } catch (SQLException e) {
            handleException(e);
        }
    }
    
    /**
     * 业务逻辑处理 - 两种方式对比
     */
    private void processBusinessLogic() {
        // ThreadLocal方式 - 需要处理null值
        UserContext tlUser = TL_USER_CONTEXT.get();
        if (tlUser == null) {
            thrownew IllegalStateException("用户上下文未设置");
        }
        
        Connection tlConn = TL_CONNECTION.get();
        if (tlConn == null) {
            thrownew IllegalStateException("数据库连接未设置");
        }
        
        // ScopedValue方式 - 在作用域内保证不为null
        UserContext svUser = SV_USER_CONTEXT.get(); // 不会为null
        Connection svConn = SV_CONNECTION.get();    // 不会为null
        
        // 实际业务处理...
        System.out.println("处理用户: " + svUser.getUserId());
    }
    
    /**
     * 线程池场景对比
     */
    public void threadPoolComparison() {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        // ThreadLocal方式 - 容易出问题
        for (int i = 0; i < 10; i++) {
            finalint userId = i;
            executor.submit(() -> {
                TL_USER_CONTEXT.set(new UserContext("user_" + userId));
                try {
                    processBusinessLogic();
                } finally {
                    TL_USER_CONTEXT.remove(); // 容易忘记或异常跳过
                }
            });
        }
        
        // ScopedValue方式 - 更安全
        for (int i = 0; i < 10; i++) {
            finalint userId = i;
            executor.submit(() -> {
                UserContext user = new UserContext("user_" + userId);
                ScopedValue.runWhere(SV_USER_CONTEXT, user, () -> {
                    processBusinessLogic(); // 自动管理生命周期
                });
            });
        }
        
        executor.shutdown();
    }
    
    private Connection getConnectionFromTL() {
        return TL_CONNECTION.get();
    }
    
    private DataSource dataSource = null; // 模拟数据源
    private void handleException(SQLException e) {} // 异常处理
}

3.3 性能对比测试

/**
 * 性能对比测试
 */
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Thread)
publicclass PerformanceComparison {
    
    privatestaticfinal ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();
    privatestaticfinal ScopedValue<String> SCOPED_VALUE = ScopedValue.newInstance();
    
    privatestaticfinalint ITERATIONS = 100000;
    
    /**
     * ThreadLocal性能测试
     */
    @Benchmark
    public void threadLocalPerformance() {
        for (int i = 0; i < ITERATIONS; i++) {
            THREAD_LOCAL.set("value_" + i);
            String value = THREAD_LOCAL.get();
            THREAD_LOCAL.remove();
        }
    }
    
    /**
     * ScopedValue性能测试
     */
    @Benchmark
    public void scopedValuePerformance() {
        for (int i = 0; i < ITERATIONS; i++) {
            ScopedValue.runWhere(SCOPED_VALUE, "value_" + i, () -> {
                String value = SCOPED_VALUE.get();
                // 自动清理,无需remove
            });
        }
    }
    
    /**
     * 实际场景性能测试
     */
    public void realScenarioTest() {
        long tlStart = System.nanoTime();
        
        // ThreadLocal场景
        THREAD_LOCAL.set("initial_value");
        for (int i = 0; i < ITERATIONS; i++) {
            String current = THREAD_LOCAL.get();
            THREAD_LOCAL.set(current + "_" + i);
        }
        THREAD_LOCAL.remove();
        
        long tlEnd = System.nanoTime();
        
        // ScopedValue场景
        long svStart = System.nanoTime();
        
        ScopedValue.runWhere(SCOPED_VALUE, "initial_value", () -> {
            String current = SCOPED_VALUE.get();
            for (int i = 0; i < ITERATIONS; i++) {
                // ScopedValue是不可变的,需要重新绑定
                String newValue = current + "_" + i;
                ScopedValue.runWhere(SCOPED_VALUE, newValue, () -> {
                    // 嵌套作用域
                    String nestedValue = SCOPED_VALUE.get();
                });
            }
        });
        
        long svEnd = System.nanoTime();
        
        System.out.printf("ThreadLocal耗时: %d ns%n", tlEnd - tlStart);
        System.out.printf("ScopedValue耗时: %d ns%n", svEnd - svStart);
    }
}

四、ScopedValue高级特性

有些小伙伴掌握了基础用法后,还想了解更高级的特性。

ScopedValue确实提供了很多强大的功能。

4.1 结构化并发支持

ScopedValue与虚拟线程和结构化并发完美配合:

/**
 * ScopedValue与结构化并发
 */
publicclass StructuredConcurrencyExample {
    
    privatestaticfinal ScopedValue<UserContext> USER_CONTEXT = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<RequestInfo> REQUEST_INFO = ScopedValue.newInstance();
    
    /**
     * 结构化并发中的ScopedValue使用
     */
    public void structuredConcurrencyWithScopedValue() throws Exception {
        UserContext user = new UserContext("structured_user");
        RequestInfo request = new RequestInfo("req_123", System.currentTimeMillis());
        
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            ScopedValue.runWhere(
                ScopedValue.where(USER_CONTEXT, user)
                          .where(REQUEST_INFO, request),
                () -> {
                    // 在作用域内提交子任务
                    Future<String> userTask = scope.fork(this::fetchUserData);
                    Future<String> orderTask = scope.fork(this::fetchOrderData);
                    Future<String> paymentTask = scope.fork(this::fetchPaymentData);
                    
                    try {
                        // 等待所有任务完成
                        scope.join();
                        scope.throwIfFailed();
                        
                        // 处理结果
                        String userData = userTask.resultNow();
                        String orderData = orderTask.resultNow();
                        String paymentData = paymentTask.resultNow();
                        
                        System.out.println("聚合结果: " + userData + ", " + orderData + ", " + paymentData);
                        
                    } catch (InterruptedException | ExecutionException e) {
                        Thread.currentThread().interrupt();
                        thrownew RuntimeException("任务执行失败", e);
                    }
                }
            );
        }
    }
    
    private String fetchUserData() {
        // 可以访问ScopedValue,无需参数传递
        UserContext user = USER_CONTEXT.get();
        RequestInfo request = REQUEST_INFO.get();
        
        return"用户数据: " + user.getUserId() + ", 请求: " + request.getRequestId();
    }
    
    private String fetchOrderData() {
        UserContext user = USER_CONTEXT.get();
        return"订单数据: " + user.getUserId();
    }
    
    private String fetchPaymentData() {
        UserContext user = USER_CONTEXT.get();
        return"支付数据: " + user.getUserId();
    }
}

class RequestInfo {
    privatefinal String requestId;
    privatefinallong timestamp;
    
    public RequestInfo(String requestId, long timestamp) {
        this.requestId = requestId;
        this.timestamp = timestamp;
    }
    
    public String getRequestId() { return requestId; }
    public long getTimestamp() { return timestamp; }
}

4.2 继承和嵌套作用域

/**
 * ScopedValue继承和嵌套
 */
publicclass ScopedValueInheritance {
    
    privatestaticfinal ScopedValue<String> PARENT_VALUE = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<String> CHILD_VALUE = ScopedValue.newInstance();
    
    /**
     * 作用域嵌套
     */
    public void nestedScopes() {
        ScopedValue.runWhere(PARENT_VALUE, "parent_value", () -> {
            System.out.println("外层作用域: " + PARENT_VALUE.get());
            
            // 内层作用域可以访问外层值
            ScopedValue.runWhere(CHILD_VALUE, "child_value", () -> {
                System.out.println("内层作用域 - 父值: " + PARENT_VALUE.get());
                System.out.println("内层作用域 - 子值: " + CHILD_VALUE.get());
                
                // 可以重新绑定父值(遮蔽)
                ScopedValue.runWhere(PARENT_VALUE, "shadowed_parent", () -> {
                    System.out.println("遮蔽作用域 - 父值: " + PARENT_VALUE.get());
                    System.out.println("遮蔽作用域 - 子值: " + CHILD_VALUE.get());
                });
                
                // 恢复原来的父值
                System.out.println("恢复作用域 - 父值: " + PARENT_VALUE.get());
            });
            
            // 子值已超出作用域
            try {
                System.out.println(CHILD_VALUE.get()); // 抛出异常
            } catch (Exception e) {
                System.out.println("子值已超出作用域: " + e.getMessage());
            }
        });
    }
    
    /**
     * 虚拟线程中的继承
     */
    public void virtualThreadInheritance() throws Exception {
        ScopedValue.runWhere(PARENT_VALUE, "virtual_parent", () -> {
            try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
                
                // 虚拟线程自动继承ScopedValue
                for (int i = 0; i < 3; i++) {
                    finalint taskId = i;
                    scope.fork(() -> {
                        // 可以访问父线程的ScopedValue
                        String parentVal = PARENT_VALUE.get();
                        return"任务" + taskId + " - 父值: " + parentVal;
                    });
                }
                
                scope.join();
                scope.throwIfFailed();
            }
        });
    }
    
    /**
     * 条件绑定
     */
    public void conditionalBinding() {
        String condition = Math.random() > 0.5 ? "case_a" : "case_b";
        
        ScopedValue.runWhere(PARENT_VALUE, condition, () -> {
            String value = PARENT_VALUE.get();
            
            if ("case_a".equals(value)) {
                System.out.println("处理情况A");
            } else {
                System.out.println("处理情况B");
            }
        });
    }
}

4.3 错误处理和调试

/**
 * ScopedValue错误处理和调试
 */
publicclass ScopedValueErrorHandling {
    
    privatestaticfinal ScopedValue<String> MAIN_VALUE = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<Integer> COUNT_VALUE = ScopedValue.newInstance();
    
    /**
     * 异常处理
     */
    public void exceptionHandling() {
        try {
            ScopedValue.runWhere(MAIN_VALUE, "test_value", () -> {
                // 业务逻辑
                processWithError();
            });
        } catch (RuntimeException e) {
            System.out.println("捕获异常: " + e.getMessage());
            // ScopedValue已自动清理,无需额外处理
        }
        
        // 验证值已清理
        try {
            String value = MAIN_VALUE.get();
            System.out.println("不应该执行到这里: " + value);
        } catch (Exception e) {
            System.out.println("值已正确清理: " + e.getMessage());
        }
    }
    
    /**
     * 调试信息
     */
    public void debugInformation() {
        ScopedValue.runWhere(
            ScopedValue.where(MAIN_VALUE, "debug_value")
                      .where(COUNT_VALUE, 42),
            () -> {
                // 获取当前绑定的所有ScopedValue
                System.out.println("当前作用域绑定:");
                System.out.println("MAIN_VALUE: " + MAIN_VALUE.get());
                System.out.println("COUNT_VALUE: " + COUNT_VALUE.get());
                
                // 模拟复杂调试
                debugComplexScenario();
            }
        );
    }
    
    /**
     * 资源清理保证
     */
    public void resourceCleanupGuarantee() {
        List<String> cleanupLog = new ArrayList<>();
        
        ScopedValue.runWhere(MAIN_VALUE, "resource_value", () -> {
            // 注册清理钩子
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                cleanupLog.add("资源清理完成");
            }));
            
            // 即使这里发生异常,ScopedValue也会清理
            if (Math.random() > 0.5) {
                thrownew RuntimeException("模拟异常");
            }
        });
        
        // 检查清理情况
        System.out.println("清理日志: " + cleanupLog);
    }
    
    private void processWithError() {
        thrownew RuntimeException("业务处理异常");
    }
    
    private void debugComplexScenario() {
        // 复杂的调试场景
        ScopedValue.runWhere(COUNT_VALUE, COUNT_VALUE.get() + 1, () -> {
            System.out.println("嵌套调试 - COUNT_VALUE: " + COUNT_VALUE.get());
        });
    }
}

五、实战案例

有些小伙伴可能还想看更复杂的实战案例。

让我们用一个Web应用中的用户上下文管理来展示ScopedValue在真实项目中的应用。

为了更直观地理解Web应用中ScopedValue的应用,我画了一个请求处理流程的架构图:

ScopedValue的生命周期如下图所示:

优势如下图所示:

5.1 定义Web应用中的ScopedValue

/**
 * Web应用ScopedValue定义
 */
publicclass WebScopedValues {
    
    // 用户上下文
    publicstaticfinal ScopedValue<UserContext> USER_CONTEXT = ScopedValue.newInstance();
    
    // 请求信息
    publicstaticfinal ScopedValue<RequestInfo> REQUEST_INFO = ScopedValue.newInstance();
    
    // 数据库连接(可选)
    publicstaticfinal ScopedValue<Connection> DB_CONNECTION = ScopedValue.newInstance();
    
    // 追踪ID
    publicstaticfinal ScopedValue<String> TRACE_ID = ScopedValue.newInstance();
}

/**
 * 用户上下文详细信息
 */
class UserContext {
    privatefinal String userId;
    privatefinal String username;
    privatefinal List<String> roles;
    privatefinal Map<String, Object> attributes;
    privatefinal Locale locale;
    
    public UserContext(String userId, String username, List<String> roles, 
                      Map<String, Object> attributes, Locale locale) {
        this.userId = userId;
        this.username = username;
        this.roles = Collections.unmodifiableList(new ArrayList<>(roles));
        this.attributes = Collections.unmodifiableMap(new HashMap<>(attributes));
        this.locale = locale;
    }
    
    // Getter方法
    public String getUserId() { return userId; }
    public String getUsername() { return username; }
    public List<String> getRoles() { return roles; }
    public Map<String, Object> getAttributes() { return attributes; }
    public Locale getLocale() { return locale; }
    
    public boolean hasRole(String role) {
        return roles.contains(role);
    }
    
    public Object getAttribute(String key) {
        return attributes.get(key);
    }
}

/**
 * 请求信息
 */
class RequestInfo {
    privatefinal String requestId;
    privatefinal String method;
    privatefinal String path;
    privatefinal String clientIp;
    privatefinal Map<String, String> headers;
    
    public RequestInfo(String requestId, String method, String path, 
                      String clientIp, Map<String, String> headers) {
        this.requestId = requestId;
        this.method = method;
        this.path = path;
        this.clientIp = clientIp;
        this.headers = Collections.unmodifiableMap(new HashMap<>(headers));
    }
    
    // Getter方法
    public String getRequestId() { return requestId; }
    public String getMethod() { return method; }
    public String getPath() { return path; }
    public String getClientIp() { return clientIp; }
    public Map<String, String> getHeaders() { return headers; }
}

5.2 过滤器实现

/**
 * 认证过滤器 - 使用ScopedValue
 */
@Component
@Slf4j
publicclass AuthenticationFilter implements Filter {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        
        // 生成请求ID
        String requestId = generateRequestId();
        
        // 提取请求信息
        RequestInfo requestInfo = extractRequestInfo(httpRequest, requestId);
        
        // 认证用户
        UserContext userContext = authenticateUser(httpRequest);
        
        // 在作用域内执行请求处理
        ScopedValue.runWhere(
            ScopedValue.where(WebScopedValues.REQUEST_INFO, requestInfo)
                      .where(WebScopedValues.USER_CONTEXT, userContext)
                      .where(WebScopedValues.TRACE_ID, requestId),
            () -> {
                try {
                    chain.doFilter(request, response);
                } catch (Exception e) {
                    log.error("请求处理异常", e);
                    thrownew RuntimeException("过滤器异常", e);
                 }
            }
        );
        
        // 作用域结束后自动清理所有ScopedValue
        log.info("请求处理完成: {}", requestId);
    }
    
    private String generateRequestId() {
        return"req_" + System.currentTimeMillis() + "_" + ThreadLocalRandom.current().nextInt(1000, 9999);
    }
    
    private RequestInfo extractRequestInfo(HttpServletRequest request, String requestId) {
        Map<String, String> headers = new HashMap<>();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            headers.put(headerName, request.getHeader(headerName));
        }
        
        returnnew RequestInfo(
            requestId,
            request.getMethod(),
            request.getRequestURI(),
            request.getRemoteAddr(),
            headers
        );
    }
    
    private UserContext authenticateUser(HttpServletRequest request) {
        String authHeader = request.getHeader("Authorization");
        
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            return tokenProvider.validateToken(token);
        }
        
        // 返回 匿名用户
        returnnew UserContext(
            "anonymous",
            "Anonymous User",
            List.of("GUEST"),
            Map.of("source", "web"),
            request.getLocale()
        );
    }
}

5.3 业务层使用

/**
 * 用户服务 - 使用ScopedValue
 */
@Service
@Slf4j
@Transactional
publicclass UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private OrderService orderService;
    
    /**
     * 获取当前用户信息
     */
    public UserProfile getCurrentUserProfile() {
        UserContext userContext = WebScopedValues.USER_CONTEXT.get();
        RequestInfo requestInfo = WebScopedValues.REQUEST_INFO.get();
        String traceId = WebScopedValues.TRACE_ID.get();
        
        log.info("[{}] 获取用户资料: {}", traceId, userContext.getUserId());
        
        // 根据用户ID查询用户信息
        User user = userRepository.findById(userContext.getUserId())
            .orElseThrow(() -> new UserNotFoundException("用户不存在: " + userContext.getUserId()));
        
        // 构建用户资料
        return UserProfile.builder()
            .userId(user.getId())
            .username(user.getUsername())
            .email(user.getEmail())
            .roles(userContext.getRoles())
            .locale(userContext.getLocale())
            .lastLogin(user.getLastLoginTime())
            .build();
    }
    
    /**
     * 更新用户信息
     */
    public void updateUserProfile(UpdateProfileRequest request) {
        UserContext userContext = WebScopedValues.USER_CONTEXT.get();
        String traceId = WebScopedValues.TRACE_ID.get();
        
        log.info("[{}] 更新用户资料: {}", traceId, userContext.getUserId());
        
        // 验证权限
        if (!userContext.getUserId().equals(request.getUserId())) {
            thrownew PermissionDeniedException("无权更新其他用户资料");
        }
        
        // 更新用户信息
        User user = userRepository.findById(request.getUserId())
            .orElseThrow(() -> new UserNotFoundException("用户不存在: " + request.getUserId()));
        
        user.setEmail(request.getEmail());
        user.setUpdateTime(LocalDateTime.now());
        
        userRepository.save(user);
        
        log.info("[{}] 用户资料更新成功: {}", traceId, userContext.getUserId());
    }
    
    /**
     * 获取用户订单列表
     */
    public List<Order> getUserOrders() {
        UserContext userContext = WebScopedValues.USER_CONTEXT.get();
        
        // 调用订单服务,无需传递用户ID
        return orderService.getUserOrders();
    }
}

/**
 * 订单服务
 */
@Service
@Slf4j
@Transactional
publicclass OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    public List<Order> getUserOrders() {
        UserContext userContext = WebScopedValues.USER_CONTEXT.get();
        String traceId = WebScopedValues.TRACE_ID.get();
        
        log.info("[{}] 查询用户订单: {}", traceId, userContext.getUserId());
        
        // 直接从ScopedValue获取用户ID,无需参数传递
        return orderRepository.findByUserId(userContext.getUserId());
    }
    
    /**
     * 创建订单
     */
    public Order createOrder(CreateOrderRequest request) {
        UserContext userContext = WebScopedValues.USER_CONTEXT.get();
        String traceId = WebScopedValues.TRACE_ID.get();
        
        log.info("[{}] 创建订单: 用户={}", traceId, userContext.getUserId());
        
        // 创建订单
        Order order = new Order();
        order.setOrderId(generateOrderId());
        order.setUserId(userContext.getUserId());
        order.setAmount(request.getTotalAmount());
        order.setStatus(OrderStatus.CREATED);
        order.setCreateTime(LocalDateTime.now());
        
        Order savedOrder = orderRepository.save(order);
        
        log.info("[{}] 订单创建成功: {}", traceId, savedOrder.getOrderId());
        
        return savedOrder;
    }
    
    private String generateOrderId() {
        return"ORD" + System.currentTimeMillis() + ThreadLocalRandom.current().nextInt(1000, 9999);
    }
}

5.4 Controller层

/**
 * 用户控制器 - 使用ScopedValue
 */
@RestController
@RequestMapping("/api/users")
@Slf4j
publicclass UserController {
    
    @Autowired
    private UserService userService;
    
    /**
     * 获取当前用户资料
     */
    @GetMapping("/profile")
    public ResponseEntity<UserProfile> getCurrentUserProfile() {
        // 无需传递用户ID,直接从ScopedValue获取
        UserProfile profile = userService.getCurrentUserProfile();
        return ResponseEntity.ok(profile);
    }
    
    /**
     * 更新用户资料
     */
    @PutMapping("/profile")
    public ResponseEntity<Void> updateUserProfile(@RequestBody @Valid UpdateProfileRequest request) {
        userService.updateUserProfile(request);
        return ResponseEntity.ok().build();
    }
    
    /**
     * 获取用户订单
     */
    @GetMapping("/orders")
    public ResponseEntity<List<Order>> getUserOrders() {
        List<Order> orders = userService.getUserOrders();
        return ResponseEntity.ok(orders);
    }
    
    /**
     * 异常处理
     */
    @ExceptionHandler({UserNotFoundException.class, PermissionDeniedException.class})
    public ResponseEntity<ErrorResponse> handleUserExceptions(RuntimeException e) {
        // 可以从ScopedValue获取请求信息用于日志
        String traceId = WebScopedValues.TRACE_ID.get();
        log.error("[{}] 用户操作异常: {}", traceId, e.getMessage());
        
        ErrorResponse error = new ErrorResponse(
            e.getClass().getSimpleName(),
            e.getMessage(),
            traceId
        );
        
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
    }
}

/**
 * 错误响应
 */
@Data
@AllArgsConstructor
class ErrorResponse {
    private String error;
    private String message;
    private String traceId;
    privatelong timestamp = System.currentTimeMillis();
}

六、迁移指南:从ThreadLocal到ScopedValue

有些小伙伴可能担心迁移成本,其实从ThreadLocal迁移到ScopedValue并不复杂。

6.1 迁移步骤

/**
 * ThreadLocal到ScopedValue迁移指南
 */
publicclass MigrationGuide {
    
    // ThreadLocal定义(旧方式)
    privatestaticfinal ThreadLocal<UserContext> TL_USER = new ThreadLocal<>();
    privatestaticfinal ThreadLocal<Connection> TL_CONN = new ThreadLocal<>();
    privatestaticfinal ThreadLocal<String> TL_TRACE = new ThreadLocal<>();
    
    // ScopedValue定义(新方式)
    privatestaticfinal ScopedValue<UserContext> SV_USER = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<Connection> SV_CONN = ScopedValue.newInstance();
    privatestaticfinal ScopedValue<String> SV_TRACE = ScopedValue.newInstance();
    
    /**
     * 迁移前:ThreadLocal方式
     */
    public void beforeMigration() {
        // 设置值
        TL_USER.set(new UserContext("user_old"));
        TL_TRACE.set("trace_old");
        
        Connection conn = null;
        try {
            conn = createConnection();
            TL_CONN.set(conn);
            
            // 业务处理
            processBusinessOld();
            
        } catch (Exception e) {
            // 异常处理
        } finally {
            // 必须手动清理
            TL_USER.remove();
            TL_TRACE.remove();
            TL_CONN.remove();
            
            if (conn != null) {
                closeConnection(conn);
            }
        }
    }
    
    /**
     * 迁移后:ScopedValue方式
     */
    public void afterMigration() {
        UserContext user = new UserContext("user_new");
        String trace = "trace_new";
        
        // 使用try-with-resources管理连接
        try (Connection conn = createConnection()) {
            
            // 在作用域内执行
            ScopedValue.runWhere(
                ScopedValue.where(SV_USER, user)
                          .where(SV_TRACE, trace)
                          .where(SV_CONN, conn),
                () -> {
                    // 业务处理
                    processBusinessNew();
                }
            );
            
            // 自动清理,无需finally块
        } catch (Exception e) {
            // 异常处理
        }
    }
    
    /**
     * 业务处理 - 旧方式
     */
    private void processBusinessOld() {
        // 需要处理null值
        UserContext user = TL_USER.get();
        if (user == null) {
            thrownew IllegalStateException("用户上下文未设置");
        }
        
        Connection conn = TL_CONN.get();
        if (conn == null) {
            thrownew IllegalStateException("数据库连接未设置");
        }
        
        String trace = TL_TRACE.get();
        
        // 业务逻辑...
        System.out.println("处理用户: " + user.getUserId() + ", 追踪: " + trace);
    }
    
    /**
     * 业务处理 - 新方式
     */
    private void processBusinessNew() {
        // 在作用域内保证不为null
        UserContext user = SV_USER.get();
        Connection conn = SV_CONN.get();
        String trace = SV_TRACE.get();
        
        // 业务逻辑...
        System.out.println("处理用户: " + user.getUserId() + ", 追踪: " + trace);
    }
    
    /**
     * 复杂迁移场景:嵌套ThreadLocal
     */
    public void complexMigration() {
        // 旧方式:嵌套ThreadLocal
        TL_USER.set(new UserContext("outer_user"));
        try {
            // 内层逻辑
            TL_USER.set(new UserContext("inner_user"));
            try {
                processBusinessOld();
            } finally {
                // 恢复外层值
                TL_USER.set(new UserContext("outer_user"));
            }
        } finally {
            TL_USER.remove();
        }
        
        // 新方式:嵌套ScopedValue
        ScopedValue.runWhere(SV_USER, new UserContext("outer_user"), () -> {
            ScopedValue.runWhere(SV_USER, new UserContext("inner_user"), () -> {
                processBusinessNew(); // 使用内层值
            });
            // 自动恢复外层值
            processBusinessNew(); // 使用外层值
        });
    }
    
    private Connection createConnection() {
        // 创建连接
        returnnull;
    }
    
    private void closeConnection(Connection conn) {
        // 关闭连接
    }
}

6.2 兼容性处理

/**
 * 兼容性处理 - 逐步迁移
 */
publicclass CompatibilityLayer {
    
    // 新代码使用ScopedValue
    privatestaticfinal ScopedValue<UserContext> SV_USER = ScopedValue.newInstance();
    
    // 旧代码可能还在使用ThreadLocal
    privatestaticfinal ThreadLocal<UserContext> TL_USER = new ThreadLocal<>();
    
    /**
     * 桥接模式:同时支持两种方式
     */
    public void bridgePattern() {
        UserContext user = new UserContext("bridge_user");
        
        // 在新作用域内执行
        ScopedValue.runWhere(SV_USER, user, () -> {
            // 同时设置ThreadLocal以兼容旧代码
            TL_USER.set(user);
            
            try {
                // 执行业务逻辑(新旧代码都可以工作)
                processMixedBusiness();
                
            } finally {
                // 清理ThreadLocal
                TL_USER.remove();
            }
        });
    }
    
    /**
     * 适配器:让旧代码使用ScopedValue
     */
    publicstaticclass ThreadLocalAdapter {
        privatefinal ScopedValue<UserContext> scopedValue;
        
        public ThreadLocalAdapter(ScopedValue<UserContext> scopedValue) {
            this.scopedValue = scopedValue;
        }
        
        public void set(UserContext user) {
            // 对于set操作,需要在适当的作用域调用
            thrownew UnsupportedOperationException("请使用ScopedValue.runWhere");
        }
        
        public UserContext get() {
            try {
                return scopedValue.get();
            } catch (Exception e) {
                // 如果不在作用域内,返回null(模拟ThreadLocal行为)
                returnnull;
            }
        }
        
        public void remove() {
            // 无需操作,ScopedValue自动管理
        }
    }
    
    /**
     * 混合业务处理
     */
    private void processMixedBusiness() {
        // 新代码使用ScopedValue
        UserContext svUser = SV_USER.get();
        System.out.println("ScopedValue用户: " + svUser.getUserId());
        
        // 旧代码使用ThreadLocal(通过桥接设置)
        UserContext tlUser = TL_USER.get();
        System.out.println("ThreadLocal用户: " + tlUser.getUserId());
        
        // 两者应该相同
        assert svUser == tlUser;
    }
    
    /**
     * 逐步迁移策略
     */
    public void gradualMigrationStrategy() {
        // 阶段1:引入ScopedValue,与ThreadLocal共存
        // 阶段2:新代码使用ScopedValue,旧代码逐步迁移
        // 阶段3:移除ThreadLocal,完全使用ScopedValue
        
        System.out.println("建议的迁移阶段:");
        System.out.println("1. 引入ScopedValue,建立桥接");
        System.out.println("2. 新功能使用ScopedValue");
        System.out.println("3. 逐步迁移旧代码");
        System.out.println("4. 移除ThreadLocal相关代码");
        System.out.println("5. 清理桥接层");
    }
}

总结

经过上面的深度剖析,我们来总结一下ScopedValue的核心优势。

核心优势

  1. 内存安全 :自动生命周期管理,彻底解决内存泄漏

  2. 使用简单 :结构化绑定,无需手动清理

  3. 性能优异 :专为虚拟线程优化,性能更好

  4. 并发友好 :完美支持结构化并发和虚拟线程

迁移决策指南

有些小伙伴在迁移时可能犹豫不决,我总结了一个决策指南:

ThreadLocal vs ScopedValue 选择口诀

  • 新项目 :直接使用ScopedValue,享受现代特性

  • 老项目 :逐步迁移,先在新模块使用

  • 性能敏感 :ScopedValue在虚拟线程中表现更佳

  • 内存敏感 :ScopedValue无内存泄漏风险

  • 团队技能 :ThreadLocal更普及,ScopedValue需要学习

技术对比

特性

ThreadLocal

ScopedValue

内存管理

手动remove

自动管理

内存泄漏

高风险

无风险

使用复杂度

高(需要try-finally)

低(结构化绑定)

性能

较好

更优(虚拟线程)

继承性

需要InheritableThreadLocal

自动继承

虚拟线程支持

有问题

完美支持

最后的建议

ScopedValue是Java并发编程的重要进步,我建议大家:

  1. 学习掌握 :尽快学习掌握ScopedValue的使用

  2. 新项目首选 :在新项目中优先使用ScopedValue

  3. 逐步迁移 :在老项目中制定合理的迁移计划

  4. 关注生态 :关注相关框架对ScopedValue的支持


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
AI时代,程序员何去何从?别慌,看完这篇你就明白了 AI时代程序员的发展方向 摘要:随着AI代码助手的普及,程序员行业面临变革。本文通过实际案例展示AI写代码的能力与局限:AI能生成基础功能代码(如RESTful API、数据处理脚本),但缺乏业务理解、系统设计和复杂逻辑处理能力。程序员的核心价值在于需求分析、架构设计、性能优化等高层能力。未来程序员应: 掌握AI工具提升效率 专注于创新和架构设计 培养业务理解能力 持续学习新技术 AI不会取代程序员,但会淘汰不会使用AI的程序员。建议开发者拥抱AI工具,将其作为助手而非威胁,聚焦高价值工作。 阅读详情

相关推荐

3D Slicer-最强大的开源医学图像分割工具简要概述

3D Slicer 是一个免费的开源软件平台,用于医学、生物医学和其他 3D 图像的可视化、处理、分割、配准和分析。读/写DICOM图像和多种其他格式;三维图像、多边形网格和体积渲染的交互式可视化;手动编辑和标记图像;使用刚性和非刚性算法融合和共同配准数据;图像自动分割;跟踪图像引导程序的设备。所有的功能模块可在工具栏里找到,提供搜索,下拉选择,左右切换等功能。3D slicer的大概情况就介绍到这里。它的功能非常强大,也没有必要说掌握每个功能的使用。

Tina姐的博客 2万+

Java 20新特性:Scoped Values 作用域值(孵化器)

Java JEP 429是 JDK 20 中引入的唯一一个新特性,目前还处于孵化器 API 的状态。它的目的是通过在线程内部和线程之间共享不可变数据,来简化线程管理。作用域值可以防止远程代码修改变量,因此可以可靠地将数据传递给同一方法中的被调用者 。

XiumingLee的博客 3076

cadence——MOS晶体管I-V特性曲线仿真

MOS晶体管I-V特性曲线仿真 目标:使用cadence绘制晶体管的I-V特性曲线(dc仿真) 流程: 新建原理图,将MOS管的栅极电压设为变量Vg,漏极电压设为变量Vd 打开ADEL,点击Variables——Copy From Cellview添加变量;并选择dc仿真,对Vd进行扫描 以Vg作为参变量进行仿真,点击Tools——Parametric Analysis进行设置 选择漏极电流作为输出,进行仿真即可得到I-V特性曲线 ...

skycmq的博客 1万+

ThreadLocal 不香了?ScopedValue才是王道?

大家好,我是不才陈某~ThreadLocal是一种实现将变量在各线程之间隔离的方案,也叫线程局部变量表。在Java中每个线程都拥有一个ThreadLocal下的ThreadLocalMap类型的变量,它用来存储定义在线程中的ThreadLocal对象,ThreadLocalMap的键是一个弱引用,指向对应的ThreadLocal对象。但值得每一位Java开发者注意的是ThreadLocal变量如果...

码猿技术专栏 707

搭建ipv6并发代理池

我开了个知识星球,把将本期搭建写成shell脚本已放到了里面,有需要的小伙伴可以自行去取,jd的参数,阿里bxet纯算、快手滑块,Pdd—Anti,ikuai,b站login之-极验3文字,某音ab,瑞数456vmp补环境等等,主要是某些大佬加我问成品,很多人都打着白嫖的手段去加我好友为目的,问完基本就以后没有任何的交集,这样的交好友雀氏没有任何意义。不如我直接开个星球,里面直接放我逆向的成品以及逆向的思路,这样大家各取所需,我也有点收益,意义更明确点,免得浪费大家的时间。我是pve下的ubuntu。

weixin_44697518的博客 1473

TwinCAT3实战:从零搭建倍福PLC的Modbus-TCP Server

本文详细介绍了如何使用TwinCAT3从零搭建倍福PLC的Modbus-TCP Server,包括环境准备、工程配置、参数设置、客户端连接测试及常见问题排查。通过实战步骤和实用技巧,帮助工程师快速掌握倍福PLC与Modbus-TCP的通信实现,提升工业自动化项目的开发效率。

weixin_30797199的博客 174

Java 25 新特性深度解析:Scoped Values 如何重塑线程上下文共享模式

A1:Scoped Value的键是全局唯一的标识符,定义为静态常量可确保整个应用中只有一个实例,避免因创建多个键导致的数据无法访问。若键定义为非静态(如实例变量),则每个对象会创建一个独立的键,不同对象无法共享同一上下文。Scoped Values作为Java 25的核心特性,不仅是ThreadLocal的“现代替代方案”,更是Java并发编程模型的一次重要升级。

weixin_54447959的博客 1251

直流无刷电机FOC控制算法 理论到实践 —— 实践

关于直流无刷电机FOC控制算法的理论章节,本人已经在前两章进行过详细说明,大家可以自行进行阅读,请务必了解过理论之后再来学习如何具体进行实现。直流无刷电机FOC控制算法 理论到实践 —— 理论(一)直流无刷电机FOC控制算法 理论到实践 —— 理论(二)本章节主要讨论采用MCU微控制器如何具体实现直流无刷电机的FOC控制。

爱出名的狗腿子 1万+

JDK8后:作用域值(Scoped Values)

在此之前我们使用TheadLocal去做多线线程的共享,JDK20的孵化特性 Scoped Values作用域值提供的更轻量的多线程共享特性。

qq_35040959的博客 632

核心组件大换血:Backbone与Neck魔改篇:YOLO26结合StarNet结构:2026星状网络在YOLO生态的即插即用实战

本文将介绍如何将StarNet作为Backbone替换YOLO26原生架构,以提升边缘设备上的目标检测性能。文章首先分析了YOLO26在特定场景下的精度瓶颈,指出其通用Backbone设计存在不足。随后深入解析StarNet的核心创新——星操作(Star Operation),这一低维计算却能获得高维特征表达的数学魔术,以及其极简的StarBlock模块设计。通过对比YOLO26原生架构的三大创新与痛点,作者提出两种替换策略:完整替换Backbone或局部替换+Neck联调。文中提供了StarNet核心代码

ZDQ58818的博客 290

【DRAM存储器六十七】DDR5介绍--训练相关之write leveling

详述DDR5 write leveling细节

highman110的博客 296

ScopedValue 全面对比 ThreadLocal:Java 上下文传递最佳实践与迁移指南

在 Java 并发编程中,线程上下文传递一直是核心痛点。传统方案 ThreadLocal 虽然普及,但在线程池复用、异步任务、虚拟线程等场景下存在脏数据、内存泄漏和可写性差等设计缺陷。ScopedValue 作为 JDK 21+ 引入的结构化并发成员,通过不可变绑定、作用域生命周期和按需可见机制,从根本上规避了这些隐患。它随代码块创建与销毁,无需手动 remove,对虚拟线程和结构化编程天然友好。从请求级上下文、跨线程传值到线程池快照迁移,ScopedValue 能覆盖大部分业务场景。本文深度对比两者差异,

weixin_29306875的博客 238

管好 SAP Fiori Launchpad Content:技术目录、业务目录与 KPI 工具的完整治理思路

SAP Fiori Launchpad 作为企业级统一入口,需通过技术目录(源对象)和业务目录(引用编排)分层治理。技术目录由 Launchpad App Manager 维护,负责应用描述对象(Tile 和 Target Mapping)的创建与管理;业务目录由 Launchpad Content Manager 编排,通过引用技术目录对象实现灵活配置。分析型内容则通过 F2814 统一管理。这种分层设计支持应用复用,便于升级维护,是 SAP S/4HANA 项目中实现高效内容治理的关键。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 134

从ThreadLocal到ScopedValue:Java并发上下文传递迁移指南

在Java并发编程中,线程局部变量(ThreadLocal)一直是处理线程级上下文传递的常用手段,然而线程池复用带来的数据串线、弱引用导致的内存泄漏,以及父子线程继承的浅拷贝问题,使其在高并发场景下隐患重重。JDK 21引入的ScopedValue以调用栈为绑定边界,通过不可变约束和自动释放机制,在性能与安全性上实现了突破,尤其适合与虚拟线程配合传递只读上下文。本文从机制原理、代码实操到迁移经验,剖析ScopedValue的设计哲学,并给出新旧技术替换的理性决策建议。围绕 ThreadLocal 与 Sco

weixin_28432777的博客 273

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【Java21】在spring boot中使用ScopedValue

本文介绍了Java 21预览功能ScopedValue在Spring Boot Web项目中的应用。ScopedValue具有不可变性和作用域限制的特点,适合在虚拟线程环境中替代ThreadLocal。文章通过具体示例演示了如何配置Maven启用预览功能,并实现通过HTTP过滤器将请求头信息存入ScopedValue上下文,在Controller和Service层读取该上下文数据。测试结果表明,ScopedValue能有效传递上下文信息,且在虚拟线程环境下同样适用。代码示例已开源在GitHub上。

qq_45362415的博客 1517

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

ScopedValue横空出世,Java开发者告别ThreadLocal的新选择!

在传统的平台线程场景下,ThreadLocal 是实现线程内数据隔离的常用工具,但它在虚拟线程大规模应用的场景中,暴露出内存泄漏风险、性能损耗、父子线程传递复杂等痛点。ScopedValue 的出现,正是为了解决这些问题,为 Java 并发编程提供更高效、更安全的局部数据传递方式。 本篇将带你快速认识 ScopedValue 的核心概念、优势,并通过第一个示例程序,迈出掌握这一特性的第一步。

y245166349的专栏 1302

再见了ThreadLocal,我决定用ScopedValue!

今天我们来聊聊一个即将改变我们编程习惯的新特性——ScopedValue。有些小伙伴在工作中,一提到线程内数据传递就想到ThreadLocal,但真正用起来却遇到各种坑:内存泄漏、数据污染、性能问题等等。其实,ScopedValue就像ThreadLocal的升级版,既保留了优点,又解决了痛点。我们一起聊聊ScopedValue的优势和用法,希望对你会有所帮助。/*** Web应用ScopedValue定义*/// 用户上下文// 请求信息// 数据库连接(可选)

dsgdauigfs的博客 970

ThreadLocal不香了,ScopedValue才是王道

绑定值时都需要指定一个方法,这个方法就是所绑定值的作用域,只有在这个作用域中的方法才能拿到所绑定的值。属性指向上一次所生成的Snapshot对象,并且在Thread类中新增了一个属性。,Snapshot对象中记录了所绑定的值,而Snapshot对象有一个。就介绍到这啦,下次继续分享JDK21新特性,欢迎大家关注我的。在Java中,当多个方法要共享一个变量时,我们会选择使用。方法中拿到的值为“xiaodudu”,但是。方法中是拿不到的(报错了),

1点25的博客 1065

JDK25的ScopedValue是什么?为什么可以替代ThreadLocal?

在一个 ScopedValue.runWhere 作用域内,使用 StructuredTaskScope.fork()(结构化并发,这个特性在 JDK25 中还是预览版)创建的所有子任务(虚拟线程)自动就能够读取到父作用域中绑定的 ScopedValue。一个 ScopedValue 的绑定在其作用域内(即 runWhere 方法定义的代码块内)对所有在该作用域中运行的代码(包括所有子任务)都是可见的。退出作用域后,绑定自动地被清除,无需手动移除,从根本上避免了内存泄漏的风险。

qq_38196449的博客 1484

ThreadLocal与ScopedValue对比讲解

*** Web应用ScopedValue定义*/// 用户上下文// 请求信息// 数据库连接(可选)// 追踪ID/*** 用户上下文详细信息*///省去get 全参/*** 请求信息*///省去get 全参。

上善若泪 910
上一篇: 为什么 Spring 和 IDEA 都不推荐使用 @Autowired 注解??
下一篇: 美团一面:循环队列听说过么,怎么实现?
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值