当前位置:

首页 > 编程开发 > SpringBoot集成ProjectLoom实战

SpringBoot集成ProjectLoom实战

ProjectLoom引入虚拟线程,由JVM管理,创建成本低且内存占用小。SpringBoot通过配置ExecutorTaskExecutor启用虚拟线程,并支持Tomcat等服务器。在控制器、服务层、数据库操作及网络请求中,同步阻塞方法可在虚拟线程中高效执行,实现同步思维编写异步代码。

本文目录

    引言

    来聊聊Spring Boot与Project Loom的集成实践。作为Ja va并发领域近年最值得关注的变化之一,Project Loom引入的虚拟线程,让我们有机会用同步的思维去写异步的代码,这确实是个很有意思的话题。下面直接进入正题。

    1. Project Loom 基础

    1.1 虚拟线程简介

    虚拟线程,说白了就是Project Loom带来的轻量级线程。它由JVM管理,而不是操作系统,所以创建成本极低,内存占用也小得多。

    // 创建虚拟线程
    Thread virtualThread = Thread.startVirtualThread(() -> {
        System.out.println("Running in virtual thread: " + Thread.currentThread());
        System.out.println("Is virtual: " + Thread.currentThread().isVirtual());
    });
    // 虚拟线程池
    ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
    IntStream.range(0, 10000).forEach(i -> {
        executor.submit(() -> {
            System.out.println("Task " + i + " in " + Thread.currentThread());
            try {
                Thread.sleep(100); // 虚拟线程中的阻塞操作不会阻塞 OS 线程
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    });

    1.2 虚拟线程 vs 平台线程

    从这张表里能看出,差异确实不小:

    特性虚拟线程平台线程
    创建成本极低高
    内存占用几 KB几 MB
    数量限制数百万数千
    阻塞行为非阻塞 OS 线程阻塞 OS 线程
    调度JVM 调度操作系统调度

    2. Spring Boot 集成

    2.1 依赖配置

    集成Spring Boot,首先把依赖加上:

    
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-webflux
            test
        
    

    2.2 配置虚拟线程

    接下来是配置。核心在于启用虚拟线程支持:

    @Configuration
    public class VirtualThreadConfig {
        @Bean
        public ExecutorTaskExecutor virtualThreadTaskExecutor() {
            ExecutorTaskExecutor executor = new ExecutorTaskExecutor();
            executor.setThreadNamePrefix("virtual-");
            executor.setVirtualThreads(true); // 启用虚拟线程
            return executor;
        }
        @Bean
        public ApplicationRunner applicationRunner() {
            return args -> {
                System.out.println("Application started with virtual threads support");
            };
        }
    }

    2.3 Web 服务器配置

    Web服务器层面也需要开启虚拟线程,以Tomcat为例:

    server:
      port: 8080
      tomcat:
        threads:
          virtual: true  # 启用 Tomcat 虚拟线程
      jetty:
        threads:
          virtual: true  # 启用 Jetty 虚拟线程
      netty:
        threads:
          virtual: true  # 启用 Netty 虚拟线程

    3. 虚拟线程实战

    3.1 控制器中使用虚拟线程

    现在写个Controller,方法本身是同步的,但在虚拟线程中执行:

    @RestController
    @RequestMapping("/api")
    public class UserController {
        private final UserService userService;
        public UserController(UserService userService) {
            this.userService = userService;
        }
        @GetMapping("/users/{id}")
        public User getUser(@PathVariable Long id) {
            // 同步方法,但在虚拟线程中执行
            return userService.findById(id);
        }
        @GetMapping("/users")
        public List getUsers() {
            // 同步方法,但在虚拟线程中执行
            return userService.findAll();
        }
    }

    3.2 服务层使用虚拟线程

    服务层也一样,数据库操作虽然是阻塞的,但虚拟线程能扛得住:

    @Service
    public class UserService {
        private final UserRepository userRepository;
        public UserService(UserRepository userRepository) {
            this.userRepository = userRepository;
        }
        // 同步方法,但在虚拟线程中执行
        public User findById(Long id) {
            // 数据库操作(阻塞操作)
            return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found"));
        }
        // 同步方法,但在虚拟线程中执行
        public List findAll() {
            // 数据库操作(阻塞操作)
            return userRepository.findAll();
        }
        // 批量操作
        public List batchProcess(List userIds) {
            return userIds.stream()
                .parallel() // 并行流,使用虚拟线程
                .map(this::findById)
                .collect(Collectors.toList());
        }
    }

    4. 异步操作

    4.1 虚拟线程中的异步操作

    异步场景下,虚拟线程同样能发挥优势,比如用CompletableFuture:

    @Service
    public class AsyncService {
        private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        public CompletableFuture processAsync(String input) {
            return CompletableFuture.supplyAsync(() -> {
                // 耗时操作
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return "Processed: " + input;
            }, executor);
        }
        public List processBatch(List inputs) {
            List> futures = inputs.stream()
                .map(this::processAsync)
                .toList();
            return futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
        }
    }

    4.2 Spring 异步支持

    Spring的@Async注解也能配合虚拟线程使用:

    @Configuration
    @EnableAsync
    public class AsyncConfig {
        @Bean(name = "virtualThreadExecutor")
        public Executor virtualThreadExecutor() {
            return Executors.newVirtualThreadPerTaskExecutor();
        }
    }
    @Service
    public class AsyncTaskService {
        @Async("virtualThreadExecutor")
        public CompletableFuture performTask(String input) {
            // 耗时操作
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return CompletableFuture.completedFuture("Task completed: " + input);
        }
    }

    5. 数据库操作

    5.1 JDBC 与虚拟线程

    JDBC操作是典型的阻塞场景,但虚拟线程能轻松应对:

    @Service
    public class JdbcUserService {
        private final JdbcTemplate jdbcTemplate;
        public JdbcUserService(JdbcTemplate jdbcTemplate) {
            this.jdbcTemplate = jdbcTemplate;
        }
        public List findAll() {
            // JDBC 操作(阻塞操作)
            return jdbcTemplate.query(
                "SELECT * FROM users",
                (rs, rowNum) -> User.builder()
                    .id(rs.getLong("id"))
                    .name(rs.getString("name"))
                    .email(rs.getString("email"))
                    .build()
            );
        }
        public User findById(Long id) {
            // JDBC 操作(阻塞操作)
            return jdbcTemplate.queryForObject(
                "SELECT * FROM users WHERE id = ?",
                new Object[]{id},
                (rs, rowNum) -> User.builder()
                    .id(rs.getLong("id"))
                    .name(rs.getString("name"))
                    .email(rs.getString("email"))
                    .build()
            );
        }
    }

    5.2 JPA 与虚拟线程

    JPA同样适用,Repository中的方法会在虚拟线程中执行:

    @Repository
    public interface UserRepository extends JpaRepository {
        // 方法会在虚拟线程中执行
        List findByNameContaining(String name);
        Optional findByEmail(String email);
    }
    @Service
    public class JpaUserService {
        private final UserRepository userRepository;
        public JpaUserService(UserRepository userRepository) {
            this.userRepository = userRepository;
        }
        @Transactional
        public User create(User user) {
            // JPA 操作(阻塞操作)
            return userRepository.sa ve(user);
        }
        @Transactional(readOnly = true)
        public List findAll() {
            // JPA 操作(阻塞操作)
            return userRepository.findAll();
        }
    }

    6. 网络操作

    6.1 HTTP 客户端

    网络请求也是虚拟线程的强项,用RestTemplate举例:

    @Service
    public class HttpClientService {
        private final RestTemplate restTemplate;
        public HttpClientService(RestTemplate restTemplate) {
            this.restTemplate = restTemplate;
        }
        public String fetchData(String url) {
            // HTTP 操作(阻塞操作)
            ResponseEntity response = restTemplate.getForEntity(url, String.class);
            return response.getBody();
        }
        public List fetchMultipleUrls(List urls) {
            return urls.stream()
                .parallel() // 并行流,使用虚拟线程
                .map(this::fetchData)
                .collect(Collectors.toList());
        }
    }

    6.2 WebClient 集成

    WebClient本身是响应式的,但也能在虚拟线程里做阻塞调用:

    @Service
    public class WebClientService {
        private final WebClient webClient;
        public WebClientService(WebClient.Builder webClientBuilder) {
            this.webClient = webClientBuilder.baseUrl("https://api.example.com").build();
        }
        // 响应式 API
        public Mono fetchDataReactive(String endpoint) {
            return webClient.get()
                .uri(endpoint)
                .retrieve()
                .bodyToMono(String.class);
        }
        // 阻塞式调用(在虚拟线程中)
        public String fetchDataBlocking(String endpoint) {
            return fetchDataReactive(endpoint).block();
        }
    }

    7. 性能对比

    7.1 传统线程池 vs 虚拟线程

    来看一组直观的对比数据:

    指标传统线程池虚拟线程
    并发数1000100000
    启动时间1-2 秒< 1 秒
    内存占用500MB+100MB+
    响应时间P99: 100ms+P99: 50ms+

    7.2 基准测试

    用基准测试来看实际效果,虚拟线程处理高并发请求的能力让人印象深刻:

    @SpringBootTest
    public class VirtualThreadBenchmark {
        @Autowired
        private UserService userService;
        @Test
        public void testConcurrentRequests() {
            int concurrentRequests = 10000;
            CountDownLatch latch = new CountDownLatch(concurrentRequests);
            ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < concurrentRequests; i++) {
                executor.submit(() -> {
                    try {
                        userService.findById(1L);
                    } finally {
                        latch.countDown();
                    }
                });
            }
            try {
                latch.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            long endTime = System.currentTimeMillis();
            System.out.println("Time for " + concurrentRequests + " requests: " + (endTime - startTime) + "ms");
        }
    }

    8. 最佳实践

    8.1 适用场景

    经验表明,以下场景特别适合虚拟线程:

    • IO 密集型任务:网络请求、数据库操作、文件 I/O
    • 高并发场景:API 服务器、微服务
    • 批处理:大量独立任务的并行处理

    8.2 注意事项

    必须警惕的是,虚拟线程并非万能。有几点需要留意:

    1. 避免 CPU 密集型任务:虚拟线程不适合 CPU 密集型操作
    2. 注意同步代码:虚拟线程中仍需注意线程安全
    3. 合理设置线程数:根据系统资源调整
    4. 监控虚拟线程:使用 JVM 工具监控虚拟线程状态

    8.3 代码示例

    最后,给一个最佳实践的例子:

    // 最佳实践:使用虚拟线程处理 IO 密集型任务
    @Service
    public class BestPracticeService {
        private final ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
        public List fetchDataFromMultipleSources(List sources) {
            return sources.stream()
                .map(source -> virtualExecutor.submit(() -> fetchFromSource(source)))
                .map(future -> {
                    try {
                        return future.get();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                })
                .collect(Collectors.toList());
        }
        private Data fetchFromSource(String source) {
            // 模拟网络请求
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return new Data(source, "data");
        }
    }

    总结

    Spring Boot与Project Loom的集成,确实为并发编程打开了一扇新的大门。通过虚拟线程,我们能以同步的写法实现异步的效果,在提升并发能力的同时,也降低了编程复杂度。当然,技术选型要因地制宜,最重要的是理解应用的实际需求,这其实可以更优雅一点。

    参考资料

    • Project Loom 官方文档
    • Spring Boot 3.2 官方文档
    • Ja va Virtual Threads Specification
    • Spring Framework 6.0 文档
    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    QQ影音怎么加速播放视频课程
    QQ影音怎么加速播放视频课程

    播放时右键选播放速度,或点控制条倍速,1.25 到 1.5 倍看课最舒服;公式代码类内容别超过 1.25 倍。

    企业微信创建企业提示失败怎么办 实名与填写检查
    企业微信创建企业提示失败怎么办 实名与填写检查

    先看提示属于哪类:名称占用就加后缀,实名不一致就重填本人信息,证件不清晰就重拍。统一社会信用代码逐位核对,连续三次失败别改材料重投,直接联系客服人工核。

    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?
    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?

    说明源码提交对字符串、生成器和数组的识别边界,以及扫描命令与发行包核验限制。

    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?
    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?

    0.170.0 的语音更新限于终端通话协商能力的明确新增,同名工具服务器跨环境支持仍标注实验性质;连接部分则修复大请求回退、认证竞态和云端重连等具体问题。这份正式版公告不足以证明所有账户、所有客户端都已具备完整语音功能。

    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?
    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?

    了解Hy4 flash、FP8与base的适用任务,阅读官方安装及图文代码,并核对资源和MaaS许可条件。

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化
    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化。说明已核实的更新范围、类型兼容性和本地版本确认方法。

    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?
    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?

    OpenAI Java SDK 4.108.0 面向 Live MCP 工具接入与 Managed Agents 预算状态处理,说明新增模型、事件含义、正式发布范围和适用限制。

    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?
    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?

    Free Claude Code 6.19.37 在自动搜索时保留客户端工具及选择条件,代理执行搜索后仍返回普通调用。说明适用场景、历史信息保留、请求约束与第三方项目的版本边界。

    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?
    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?

    Google GenAI Go SDK 1.78.0 将 Gemini Developer API 默认改为 v1,可用 HTTPOptions.APIVersion 或环境变量保留 v1beta,Vertex AI 默认值不变。

    Google GenAI SDK 3.5.0实时交互值得哪些项目升级评估?
    Google GenAI SDK 3.5.0实时交互值得哪些项目升级评估?

    解释实验性实时支持、环境检查与生产评估中需要验证的条件。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。