<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.0.0</version>
    <relativePath/>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

# application.yml
spring:
  # 全局啟用虛擬線程
  threads:
    virtual:
      enabled: true
server:
  port: 8080
  # 可選：Tomcat相關(guān)配置（虛擬線程模式下無(wú)需手動(dòng)配置線程池大小，JVM自動(dòng)管理）
  tomcat:
    threads:
      max: 200 # 載體線程最大數(shù)量（默認(rèn)值即可，無(wú)需過(guò)度調(diào)整）
    connection-timeout: 20000
    max-connections: 10000 # 最大連接數(shù)，配合虛擬線程提升并發(fā)

package com.example.virtualthread.controller;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/test")
@Slf4j
public class VirtualThreadTestController {
    /**
     * 測(cè)試全局虛擬線程啟用效果
     */
    @GetMapping("/global-virtual")
    public String testGlobalVirtualThread() {
        // 獲取當(dāng)前線程
        Thread currentThread = Thread.currentThread();
        // 打印線程信息：線程名、是否為虛擬線程、線程ID
        log.info("當(dāng)前線程信息：name={}, isVirtual={}, id={}",
                currentThread.getName(),
                currentThread.isVirtual(),
                currentThread.getId());
        return "全局虛擬線程測(cè)試成功！線程信息已打印到日志";
    }
}

2025-12-10 10:00:00.000  INFO 12345 --- [  virtual-123] c.e.v.controller.VirtualThreadTestController  : 當(dāng)前線程信息：name=virtual-123, isVirtual=true, id=123

package com.example.virtualthread.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.VirtualThreadTaskExecutor;
@Configuration
public class VirtualThreadConfig {
    /**
     * 創(chuàng)建虛擬線程執(zhí)行器Bean
     * 后續(xù)可通過(guò)@Autowired注入，為指定任務(wù)分配虛擬線程
     */
    @Bean(name = "virtualThreadExecutor")
    public TaskExecutor virtualThreadExecutor() {
        // VirtualThreadTaskExecutor是Spring Boot 4.0新增的虛擬線程執(zhí)行器
        return new VirtualThreadTaskExecutor("custom-virtual-"); // 線程名前綴
    }
}

package com.example.virtualthread.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.task.TaskExecutor;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
@Service
@Slf4j
public class VirtualThreadService {
    // 注入自定義的虛擬線程執(zhí)行器
    @Autowired
    @Qualifier("virtualThreadExecutor")
    private TaskExecutor virtualThreadExecutor;
    /**
     * 局部使用虛擬線程執(zhí)行任務(wù)
     */
    public CompletableFuture<String> doTaskWithVirtualThread() {
        // 使用虛擬線程執(zhí)行器提交異步任務(wù)
        return CompletableFuture.runAsync(() -> {
            Thread currentThread = Thread.currentThread();
            log.info("局部虛擬線程任務(wù)執(zhí)行：name={}, isVirtual={}, id={}",
                    currentThread.getName(),
                    currentThread.isVirtual(),
                    currentThread.getId());
            // 模擬IO阻塞（如數(shù)據(jù)庫(kù)查詢(xún)、網(wǎng)絡(luò)請(qǐng)求）
            try {
                Thread.sleep(1000); // 虛擬線程會(huì)在此處掛起，釋放載體線程
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("線程執(zhí)行異常", e);
            }
        }, virtualThreadExecutor).thenApply(v -> "局部虛擬線程任務(wù)執(zhí)行完成");
    }
    /**
     * 對(duì)比：使用默認(rèn)平臺(tái)線程執(zhí)行任務(wù)
     */
    public CompletableFuture<String> doTaskWithPlatformThread() {
        // 使用默認(rèn)的ForkJoinPool（平臺(tái)線程）執(zhí)行任務(wù)
        return CompletableFuture.runAsync(() -> {
            Thread currentThread = Thread.currentThread();
            log.info("平臺(tái)線程任務(wù)執(zhí)行：name={}, isVirtual={}, id={}",
                    currentThread.getName(),
                    currentThread.isVirtual(),
                    currentThread.getId());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("線程執(zhí)行異常", e);
            }
        }).thenApply(v -> "平臺(tái)線程任務(wù)執(zhí)行完成");
    }
}

@GetMapping("/local-virtual")
public CompletableFuture<String> testLocalVirtualThread() {
    return virtualThreadService.doTaskWithVirtualThread();
}
@GetMapping("/platform-thread")
public CompletableFuture<String> testPlatformThread() {
    return virtualThreadService.doTaskWithPlatformThread();
}

package com.example.virtualthread.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.VirtualThreadTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
@EnableAsync // 啟用異步任務(wù)支持
public class AsyncVirtualThreadConfig {
    /**
     * 配置@Async默認(rèn)使用的虛擬線程池
     */
    @Bean
    public Executor asyncVirtualThreadExecutor() {
        // 若需指定線程名前綴，可傳入?yún)?shù)：new VirtualThreadTaskExecutor("async-virtual-")
        return new VirtualThreadTaskExecutor();
    }
}

package com.example.virtualthread.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
@Slf4j
public class AsyncVirtualThreadService {
    /**
     * 異步任務(wù)，使用虛擬線程執(zhí)行
     */
    @Async // 未指定executor時(shí)，使用默認(rèn)的asyncVirtualThreadExecutor
    public void asyncTaskWithVirtualThread() {
        Thread currentThread = Thread.currentThread();
        log.info("異步任務(wù)-虛擬線程：name={}, isVirtual={}, id={}",
                currentThread.getName(),
                currentThread.isVirtual(),
                currentThread.getId());
        // 模擬IO阻塞
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("異步任務(wù)執(zhí)行異常", e);
        }
    }
}

@GetMapping("/async-virtual")
public String testAsyncVirtualThread() {
    asyncVirtualThreadService.asyncTaskWithVirtualThread();
    return "異步虛擬線程任務(wù)已提交，查看日志驗(yàn)證";
}
    

2025-12-10 10:30:00.000  INFO 12345 --- [  virtual-456] c.e.v.service.AsyncVirtualThreadService  : 異步任務(wù)-虛擬線程：name=virtual-456, isVirtual=true, id=456

/**
 * 虛擬線程性能測(cè)試接口（IO密集型）
 */
@GetMapping("/performance/virtual")
public String performanceTestVirtual() {
    // 模擬IO阻塞（如數(shù)據(jù)庫(kù)查詢(xún)、Redis操作）
    try {
        Thread.sleep(1000); // 關(guān)鍵：IO阻塞時(shí)虛擬線程會(huì)掛起
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return "測(cè)試失敗";
    }
    return "虛擬線程測(cè)試成功";
}

/**
 * 平臺(tái)線程性能測(cè)試接口（IO密集型）
 */
@GetMapping("/performance/platform")
public String performanceTestPlatform() {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return "測(cè)試失敗";
    }
    return "平臺(tái)線程測(cè)試成功";
}
    

# 平臺(tái)線程測(cè)試時(shí)的配置
spring:
  threads:
    virtual:
      enabled: false
server:
  tomcat:
    threads:
      min-spare: 50
      max: 200 # 平臺(tái)線程池最大線程數(shù)（傳統(tǒng)Web應(yīng)用常用配置）
    max-connections: 10000

// 示例：Spring Scheduler使用虛擬線程
@Configuration
@EnableScheduling
public class SchedulerVirtualThreadConfig {
    @Bean
    public ScheduledExecutorService scheduledExecutorService() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }
    @Scheduled(fixedRate = 1000)
    public void scheduledTask() {
        log.info("定時(shí)任務(wù)-虛擬線程：name={}, isVirtual={}",
                Thread.currentThread().getName(),
                Thread.currentThread().isVirtual());
    }
}