从源码看Spring Boot 3.2新特性：虚拟线程如何让Web性能暴涨300%（保姆级讲解）

spring:
  threads:
    virtual:
      enabled: true

@SpringBootApplication
@EnableVirtualThreads
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@AutoConfiguration
@ConditionalOnClass(Executors.class)
@ConditionalOnProperty(prefix = "spring.threads.virtual", name = "enabled", havingValue = "true")
public class VirtualThreadAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public VirtualThreadsExecutorServiceConfigurer virtualThreadsExecutorServiceConfigurer() {
        return new VirtualThreadsExecutorServiceConfigurer();
    }
}

public class VirtualThreadsExecutorServiceConfigurer implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof TomcatProtocolHandlerCustomizer<?>) {
            // 跳过，避免循环处理
            return bean;
        }
        if (bean instanceof ExecutorService) {
            return wrapExecutorService((ExecutorService) bean);
        }
        if (bean instanceof AsyncTaskExecutor) {
            return wrapAsyncTaskExecutor((AsyncTaskExecutor) bean);
        }
        return bean;
    }

    private ExecutorService wrapExecutorService(ExecutorService executor) {
        // 关键点：判断是否是平台线程池
        if (isPlatformThreadPool(executor)) {
            return new VirtualThreadExecutorServiceWrapper(executor);
        }
        return executor;
    }
}

class TomcatVirtualThreadsCustomizer implements TomcatConnectorCustomizer {

    @Override
    public void customize(Connector connector) {
        ProtocolHandler protocolHandler = connector.getProtocolHandler();
        if (protocolHandler instanceof AbstractProtocol<?> abstractProtocol) {
            Executor executor = abstractProtocol.getExecutor();
            if (executor == null) {
                // 设置虚拟线程执行器
                ExecutorService virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor();
                abstractProtocol.setExecutor(new VirtualThreadExecutorWrapper(virtualThreadExecutor));
            }
        }
    }
}

@RestController
public class TestController {

    @GetMapping("/test")
    public String test() throws InterruptedException {
        // 模拟IO操作
        Thread.sleep(100);
        return "ok";
    }
}

wrk -t10 -c200 -d30s http://localhost:8080/test

Requests/sec:   1987.32
Transfer/sec:    248.41KB

Requests/sec:   7956.45
Transfer/sec:    994.56KB

// AbstractProtocol.java - Tomcat源码
public void process(SocketWrapperBase<?> socketWrapper, SocketEvent event) {
    // 从Executor中获取线程执行
    getExecutor().execute(() -> {
        // 处理请求
        processor.process(socketWrapper, event);
    });
}

// VirtualThreadExecutorWrapper.java
public void execute(Runnable command) {
    // 每个任务创建一个新的虚拟线程
    Thread.startVirtualThread(() -> {
        try {
            command.run();
        } catch (Exception e) {
            // 异常处理
        }
    });
}

// Thread.java - JDK源码
public static void sleep(long millis) throws InterruptedException {
    if (currentThread() instanceof VirtualThread vthread) {
        // 虚拟线程的特殊处理
        vthread.sleep(millis);
        return;
    }
    // 平台线程的原始处理
    sleep0(millis);
}

// VirtualThread.java
void sleep(long millis) throws InterruptedException {
    // 将当前虚拟线程从载体线程卸载
    yieldContinuation();
    // 注册定时唤醒
    scheduleWakeup(millis);
    // 等待重新调度
    park();
}

// ❌ 旧的写法
ExecutorService executor = Executors.newFixedThreadPool(10);

// ✅ 新的写法 - 虚拟线程版本
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

// 或者保留平台线程池，但包装成虚拟线程
ExecutorService executor = Executors.newThreadPerTaskExecutor(
    Thread.ofVirtual().factory()
);

public class VirtualThreadSyncExample {
    
    private static final Object lock = new Object();
    
    public void handleRequest() {
        // synchronized会导致虚拟线程被固定(pinned)到平台线程
        synchronized(lock) {
            // 执行需要同步的操作
            doSomething();
        }
        // 离开synchronized块后，虚拟线程可以再次迁移
    }
}