Virtual Threads vs WebFlux: Which to Choose in 2026

//MvcApp.java
package com.javabrahman.reactive.vt.mvc;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class MvcApp {

  @GetMapping("/quote")
  public String quote() throws InterruptedException {
    String thread = Thread.currentThread().toString();
    Thread.sleep(200);   // a blocking call to a slow service
    return thread;
  }
}

//FluxApp.java
package com.javabrahman.reactive.vt.flux;

import io.netty.channel.ChannelOption;
import java.time.Duration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.reactor.netty.NettyServerCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@SpringBootApplication
@RestController
public class FluxApp {

  @GetMapping("/quote")
  public Mono<String> quote() {
    String thread = Thread.currentThread().toString();
    return Mono.just(thread).delayElement(Duration.ofMillis(200));   // a non-blocking call to a slow service
  }

  @GetMapping("/blocking")
  public Mono<String> blocking() throws InterruptedException {
    String thread = Thread.currentThread().toString();
    Thread.sleep(200);   // WRONG in WebFlux: blocks an event-loop thread
    return Mono.just(thread);
  }

  // for the load test only: a longer queue of incoming connections than the operating system's default
  @Bean
  NettyServerCustomizer longerAcceptQueue() {
    return server -> server.option(ChannelOption.SO_BACKLOG, 4096);
  }
}

//LoadTest.java
package com.javabrahman.reactive.vt;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ConfigurableApplicationContext;

public class LoadTest {

  // args: application class, path, number of requests, then extra Spring Boot arguments
  public static void main(String[] args) throws Exception {
    Class<?> app = Class.forName(args[0]);
    String path = args[1];
    int requests = Integer.parseInt(args[2]);
    List<String> bootArgs = new ArrayList<>(Arrays.asList(args).subList(3, args.length));
    bootArgs.add("--server.port=0");
    try (ConfigurableApplicationContext context = SpringApplication.run(app, bootArgs.toArray(String[]::new));
         HttpClient http = HttpClient.newBuilder().executor(Executors.newVirtualThreadPerTaskExecutor()).build()) {
      URI uri = URI.create("http://localhost:" + context.getEnvironment().getProperty("local.server.port") + path);
      fire(http, uri, requests);   // warm-up: opens the connections, which the measured round reuses
      Set<String> threads = ConcurrentHashMap.newKeySet();
      long start = System.nanoTime();
      List<String> answers = fire(http, uri, requests);
      double seconds = Math.round((System.nanoTime() - start) / 100_000_000.0) / 10.0;
      answers.forEach(threads::add);
      System.out.println(requests + " requests at once: all answered after " + seconds + " s");
      System.out.println("server threads used: " + threads.size()
          + ", for example " + answers.get(0).replaceAll("#\\d+", "#N").replaceAll("-\\d+", "-N"));
    }
  }

  static List<String> fire(HttpClient http, URI uri, int count) throws Exception {
    CountDownLatch go = new CountDownLatch(1);
    List<Future<String>> futures = new ArrayList<>();
    try (ExecutorService clients = Executors.newVirtualThreadPerTaskExecutor()) {
      for (int i = 0; i < count; i++) {
        futures.add(clients.submit(() -> {
          go.await();
          for (int attempt = 1; ; attempt++) {
            try {
              return http.send(HttpRequest.newBuilder(uri).build(), HttpResponse.BodyHandlers.ofString()).body();
            } catch (java.net.ConnectException e) {   // the server's accept queue overflowed: try again shortly
              if (attempt == 50) {
                throw e;
              }
              Thread.sleep(java.util.concurrent.ThreadLocalRandom.current().nextInt(20, 200));   // spread the retries
            }
          }
        }));
      }
      go.countDown();   // all requests leave together
    }
    List<String> answers = new ArrayList<>();
    for (Future<String> f : futures) {
      answers.add(f.get());
    }
    return answers;
  }
}

//Cores.java
package com.javabrahman.reactive.vt;

public class Cores {

  public static void main(String[] args) {
    System.out.println("CPU cores: " + Runtime.getRuntime().availableProcessors());
  }
}