Spring Boot 3.4 Virtual Threads : questions d'entretien et benchmarks de performance

// Comparaison de la création de threads
public class VirtualThreadDemo {

    public void demonstrateDifference() {
        // Platform Thread : ~1MB de stack par thread
        // Limite pratique : quelques milliers sur une JVM standard
        Thread platformThread = new Thread(() -> {
            performBlockingOperation();
        });

        // Virtual Thread : ~quelques KB par thread
        // Peut en créer des millions sans problème
        Thread virtualThread = Thread.ofVirtual().start(() -> {
            performBlockingOperation();
        });
    }

    // Un Virtual Thread "monte" sur un Platform Thread (carrier)
    // Lors d'un blocage I/O, il libère le carrier pour d'autres Virtual Threads
    private void performBlockingOperation() {
        try {
            Thread.sleep(1000); // Le Virtual Thread se détache du carrier ici
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

# application.yml
# Activation globale des Virtual Threads
spring:
  threads:
    virtual:
      enabled: true

# Configuration optionnelle du pool Tomcat
server:
  tomcat:
    threads:
      max: 200  # Moins critique avec Virtual Threads
      min-spare: 10

// Activation programmatique si nécessaire
@Configuration
public class WebConfig {

    @Bean
    public TomcatProtocolHandlerCustomizer<?> virtualThreadCustomizer() {
        // Chaque requête HTTP s'exécute sur un Virtual Thread
        return protocolHandler -> {
            protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        };
    }
}

// Illustration du cycle mounting/unmounting
public class MountingDemo {

    public void demonstrateMounting() {
        Thread.ofVirtual().start(() -> {
            // MOUNTED : le Virtual Thread utilise un carrier thread
            System.out.println("Carrier: " + getCurrentCarrier());

            // UNMOUNTING : libère le carrier pendant le blocage
            performDatabaseQuery(); // Appel JDBC bloquant

            // REMOUNTED : peut être sur un carrier différent
            System.out.println("Nouveau carrier: " + getCurrentCarrier());
        });
    }

    // Les opérations bloquantes déclenchent l'unmounting automatiquement
    private void performDatabaseQuery() {
        // Connection JDBC, lecture fichier, appel réseau...
        // Le Virtual Thread se détache pendant l'attente I/O
    }

    private String getCurrentCarrier() {
        // Récupère le nom du thread porteur actuel
        return Thread.currentThread().toString();
    }
}

// Cas idéal pour Virtual Threads
@Service
public class IOBoundService {

    private final RestClient restClient;
    private final UserRepository userRepository;

    // Chaque appel implique de l'attente réseau et BDD
    // Les Virtual Threads brillent ici
    public UserProfile enrichUserProfile(Long userId) {
        // Appel BDD - le VT se détache pendant la requête SQL
        User user = userRepository.findById(userId).orElseThrow();

        // Appel REST externe - le VT se détache pendant l'attente HTTP
        ExternalData externalData = restClient
            .get()
            .uri("/api/external/{id}", userId)
            .retrieve()
            .body(ExternalData.class);

        // Agrégation des données
        return new UserProfile(user, externalData);
    }
}

// Exemples de cas à éviter
@Service
public class AntiPatterns {

    // ANTI-PATTERN 1 : Calcul CPU-intensif
    // Les Virtual Threads n'apportent rien ici
    public BigInteger computeFactorial(int n) {
        // 100% CPU, aucun I/O, pas d'unmounting possible
        BigInteger result = BigInteger.ONE;
        for (int i = 2; i <= n; i++) {
            result = result.multiply(BigInteger.valueOf(i));
        }
        return result; // Le carrier est monopolisé tout le long
    }

    // ANTI-PATTERN 2 : Synchronized cause le pinning
    private final Object lock = new Object();

    public void pinnedOperation() {
        synchronized (lock) { // PINNING : le VT reste sur le carrier
            performDatabaseQuery(); // L'unmounting ne se produit pas !
        }
    }

    // SOLUTION : Utiliser ReentrantLock
    private final ReentrantLock reentrantLock = new ReentrantLock();

    public void unpinnedOperation() {
        reentrantLock.lock();
        try {
            performDatabaseQuery(); // Unmounting possible
        } finally {
            reentrantLock.unlock();
        }
    }
}

// Configuration et détection du pinning
public class PinningDiagnostics {

    // Option JVM pour logger le pinning
    // -Djdk.tracePinnedThreads=full (détaillé)
    // -Djdk.tracePinnedThreads=short (résumé)

    // Exemple de code causant du pinning
    public void demonstratePinning() {
        Thread.ofVirtual().start(() -> {
            synchronized (this) {
                // Ce log apparaîtra avec tracePinnedThreads activé
                try {
                    Thread.sleep(100); // Pinned pendant le sleep !
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }
}

# Sortie typique avec -Djdk.tracePinnedThreads=full
Thread[#23,VirtualThread[#1]/runnable@ForkJoinPool-1-worker-1,5,CarrierThreads]
    java.base/java.lang.VirtualThread$VThreadContinuation.onPinned(VirtualThread.java:183)
    java.base/java.lang.VirtualThread.parkOnCarrierThread(VirtualThread.java:661)
    com.example.PinningDiagnostics.demonstratePinning(PinningDiagnostics.java:15)

// Endpoint pour mesurer les performances
@RestController
@RequestMapping("/api/benchmark")
public class BenchmarkController {

    private final ExternalApiClient apiClient;

    // Simulation d'un endpoint typique avec appels externes
    @GetMapping("/user/{id}")
    public ResponseEntity<UserData> getUser(@PathVariable Long id) {
        // Trois appels I/O séquentiels
        UserInfo info = apiClient.fetchUserInfo(id);        // ~50ms
        List<Order> orders = apiClient.fetchOrders(id);     // ~80ms
        CreditScore score = apiClient.fetchCreditScore(id); // ~100ms

        return ResponseEntity.ok(new UserData(info, orders, score));
    }
}

# Résultats benchmark - 10 000 requêtes concurrentes
# Configuration : 8 cœurs, 16GB RAM, latence simulée 230ms/requête

Platform Threads (pool 200) :
- Throughput : 850 req/s
- P99 latence : 1250ms
- Mémoire heap : 2.1GB

Virtual Threads :
- Throughput : 4200 req/s
- P99 latence : 280ms
- Mémoire heap : 850MB

Gain : x5 throughput, x4.5 réduction latence P99

# application.yml
# Configuration HikariCP optimisée pour Virtual Threads
spring:
  datasource:
    hikari:
      # Plus de connexions car les Virtual Threads permettent plus de concurrence
      maximum-pool-size: 50
      minimum-idle: 10
      # Timeout plus court car plus de demandes concurrentes
      connection-timeout: 5000
      # Validation rapide
      validation-timeout: 3000

  # Redis avec Lettuce - déjà async-friendly
  data:
    redis:
      lettuce:
        pool:
          max-active: 50
          max-idle: 20

// Monitoring du pool pour éviter la contention
@Component
public class ConnectionPoolMonitor {

    private final HikariDataSource dataSource;

    @Scheduled(fixedRate = 10000)
    public void logPoolStats() {
        HikariPoolMXBean pool = dataSource.getHikariPoolMXBean();
        log.info("Pool stats - Active: {}, Idle: {}, Waiting: {}",
            pool.getActiveConnections(),
            pool.getIdleConnections(),
            pool.getThreadsAwaitingConnection());

        // Alerte si trop de threads en attente
        if (pool.getThreadsAwaitingConnection() > 100) {
            log.warn("Connection pool contention detected!");
        }
    }
}

// Métriques personnalisées pour Virtual Threads
@Component
public class VirtualThreadMetrics {

    private final MeterRegistry registry;
    private final AtomicLong activeVirtualThreads = new AtomicLong(0);

    @PostConstruct
    public void registerMetrics() {
        // Compteur de Virtual Threads actifs
        Gauge.builder("virtual.threads.active", activeVirtualThreads, AtomicLong::get)
            .description("Number of active virtual threads")
            .register(registry);

        // Métriques JVM pour les carriers
        Gauge.builder("virtual.threads.carriers", this::getCarrierCount)
            .description("Number of carrier threads")
            .register(registry);
    }

    private double getCarrierCount() {
        // Récupère le nombre de carriers du ForkJoinPool
        return ForkJoinPool.commonPool().getPoolSize();
    }

    // Intercepteur pour tracer les requêtes
    public void trackVirtualThread(Runnable task) {
        activeVirtualThreads.incrementAndGet();
        try {
            task.run();
        } finally {
            activeVirtualThreads.decrementAndGet();
        }
    }
}

# application.yml
# Exposition des métriques
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  metrics:
    tags:
      application: ${spring.application.name}

// Vérification de la compatibilité des dépendances
@Configuration
public class CompatibilityCheck {

    // Bibliothèques compatibles (versions recommandées)
    // - Spring Boot 3.2+ (support natif)
    // - HikariCP 5.1+ (ReentrantLock au lieu de synchronized)
    // - Lettuce 6.3+ (I/O non-bloquant)
    // - Jackson 2.16+ (pas de synchronized)

    // Bibliothèques nécessitant attention
    // - JDBC drivers : vérifier la version
    // - Certains clients HTTP legacy

    @Bean
    public CommandLineRunner checkCompatibility() {
        return args -> {
            // Log des versions pour audit
            log.info("Java version: {}", System.getProperty("java.version"));
            log.info("Virtual threads available: {}",
                Thread.ofVirtual() != null);

            // Vérification du support
            if (Runtime.version().feature() < 21) {
                throw new IllegalStateException(
                    "Java 21+ required for Virtual Threads");
            }
        };
    }
}

// Configuration pour migration progressive
@Configuration
public class DualExecutorConfig {

    // Executor traditionnel pour les endpoints legacy
    @Bean("platformExecutor")
    public ExecutorService platformExecutor() {
        return Executors.newFixedThreadPool(200);
    }

    // Executor Virtual Threads pour les nouveaux endpoints
    @Bean("virtualExecutor")
    public ExecutorService virtualExecutor() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }
}

@RestController
@RequestMapping("/api/v2")
public class MigratedController {

    @Qualifier("virtualExecutor")
    private final ExecutorService executor;

    // Endpoint migré vers Virtual Threads
    @GetMapping("/users/{id}")
    public CompletableFuture<User> getUser(@PathVariable Long id) {
        return CompletableFuture.supplyAsync(() -> {
            // Code métier inchangé
            return userService.findById(id);
        }, executor);
    }
}

# application.yml
# Feature flag pour la migration
features:
  virtual-threads:
    enabled: true
    endpoints:
      - /api/v2/**
      - /api/reports/**

# Désactiver pour rollback rapide
# features.virtual-threads.enabled: false

// Test de charge avec JUnit et Virtual Threads
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class VirtualThreadLoadTest {

    @LocalServerPort
    private int port;

    @Test
    void shouldHandleHighConcurrency() throws Exception {
        int concurrentRequests = 5000;
        CountDownLatch latch = new CountDownLatch(concurrentRequests);
        AtomicInteger successCount = new AtomicInteger(0);
        AtomicInteger errorCount = new AtomicInteger(0);

        HttpClient client = HttpClient.newHttpClient();

        // Lance 5000 requêtes simultanées
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < concurrentRequests; i++) {
                executor.submit(() -> {
                    try {
                        HttpRequest request = HttpRequest.newBuilder()
                            .uri(URI.create("http://localhost:" + port + "/api/test"))
                            .build();

                        HttpResponse<String> response = client.send(
                            request, BodyHandlers.ofString());

                        if (response.statusCode() == 200) {
                            successCount.incrementAndGet();
                        } else {
                            errorCount.incrementAndGet();
                        }
                    } catch (Exception e) {
                        errorCount.incrementAndGet();
                    } finally {
                        latch.countDown();
                    }
                });
            }
        }

        latch.await(60, TimeUnit.SECONDS);

        // Assertions sur les performances
        assertThat(successCount.get()).isGreaterThan(4900); // >98% succès
        assertThat(errorCount.get()).isLessThan(100);
    }
}

// Combinaison Virtual Threads + Structured Concurrency
public class StructuredConcurrencyExample {

    public UserDashboard fetchDashboard(Long userId) throws Exception {
        // StructuredTaskScope garantit que toutes les tâches se terminent ensemble
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

            // Trois tâches parallèles sur Virtual Threads
            Subtask<UserProfile> profileTask = scope.fork(() ->
                userService.getProfile(userId));

            Subtask<List<Notification>> notifTask = scope.fork(() ->
                notificationService.getRecent(userId));

            Subtask<AccountBalance> balanceTask = scope.fork(() ->
                accountService.getBalance(userId));

            // Attend toutes les tâches ou échoue sur la première erreur
            scope.join();
            scope.throwIfFailed();

            // Toutes les tâches ont réussi - agrégation sécurisée
            return new UserDashboard(
                profileTask.get(),
                notifTask.get(),
                balanceTask.get()
            );
        }
        // Si une tâche échoue, les autres sont automatiquement annulées
    }
}

// Même logique : impératif vs reactive
@Service
public class ComparisonService {

    // APPROCHE VIRTUAL THREADS : code impératif classique
    // Simple à lire, déboguer et maintenir
    public UserData getUserDataImperative(Long id) {
        User user = userRepository.findById(id).orElseThrow();
        List<Order> orders = orderRepository.findByUserId(id);
        PaymentInfo payment = paymentService.getInfo(id);

        return new UserData(user, orders, payment);
    }

    // APPROCHE REACTIVE : flux et opérateurs
    // Plus complexe mais backpressure natif
    public Mono<UserData> getUserDataReactive(Long id) {
        return userRepository.findById(id)
            .zipWith(orderRepository.findByUserId(id).collectList())
            .zipWith(paymentService.getInfo(id))
            .map(tuple -> new UserData(
                tuple.getT1().getT1(),
                tuple.getT1().getT2(),
                tuple.getT2()
            ));
    }
}

// Comparaison des approches de contexte
public class ThreadLocalVsScopedValue {

    // APPROCHE CLASSIQUE : ThreadLocal
    // Fonctionne mais coûteux en mémoire avec millions de VT
    private static final ThreadLocal<RequestContext> requestContext =
        new ThreadLocal<>();

    public void processWithThreadLocal(Request request) {
        requestContext.set(new RequestContext(request.getTraceId()));
        try {
            // Le contexte est accessible partout dans le thread
            processRequest();
        } finally {
            requestContext.remove(); // Important pour éviter les fuites
        }
    }

    // APPROCHE MODERNE : ScopedValue (Java 21+)
    // Plus efficace, immuable, scope explicite
    private static final ScopedValue<RequestContext> CONTEXT =
        ScopedValue.newInstance();

    public void processWithScopedValue(Request request) {
        ScopedValue.where(CONTEXT, new RequestContext(request.getTraceId()))
            .run(() -> {
                // Le contexte est accessible dans ce scope
                processRequest();
                // Pas besoin de cleanup - automatique à la fin du scope
            });
    }

    private void processRequest() {
        // Accès au contexte
        String traceId = CONTEXT.isBound()
            ? CONTEXT.get().getTraceId()
            : "unknown";
        log.info("Processing with trace: {}", traceId);
    }
}