Roman Kryvolapov Engineering Blog

Введение в Project Loom

Project Loom — это проект, разрабатываемый Oracle для Java, который добавляет лёгкие потоки или "виртуальные потоки" в язык. Цель Project Loom — упростить написание параллельного кода, позволив использовать асинхронное выполнение без явного использования сложных абстракций вроде потоков, коллбеков или корутин.

Основные особенности

Виртуальные потоки:
основное новшество Loom. Виртуальные потоки — это легковесные потоки, реализованные на уровне JVM, которые позволяют обрабатывать тысячи или даже миллионы задач параллельно.

Поддержка параллельных вызовов:
благодаря виртуальным потокам, можно писать блокирующий код (например, синхронные вызовы sleep, wait или I/O-операции), который будет при этом выполнять задачи параллельно.

Поддержка с JDK 19:
виртуальные потоки появились как превью-функция в JDK 19, а в JDK 21 стали стабильной (финальной) функцией.

Преимущества

Упрощённый асинхронный код:
Код, написанный с виртуальными потоками, может быть линейным и блокирующим, не требует асинхронных API или сложных конструкций.

Уменьшенные накладные расходы:
Нет необходимости создавать реальные потоки ОС для каждой задачи, что снижает накладные расходы и позволяет JVM выполнять сотни тысяч виртуальных потоков на ограниченном количестве потоков ОС.

Масштабируемость:
Виртуальные потоки делают масштабируемыми приложения, обрабатывающие большое количество параллельных задач (например, высоконагруженные серверы).

Недостатки

Зависимость от JVM:
Loom работает только на JVM, что ограничивает его использование, если требуется совместимость с другой платформой или версией Java ниже JDK 19.

Ограниченная поддержка и стабильность:
Project Loom всё ещё находится на стадии разработки и требует дальнейших улучшений и оптимизации.

Отсутствие функциональности реактивных библиотек:
Loom не предлагает встроенных инструментов для реактивного программирования, таких как трансформации данных и операторы, которые есть в библиотеках типа RxJava.

Принцип работы

Создание виртуального потока:

Виртуальные потоки создаются аналогично обычным потокам Java (Thread), но они гораздо легче и не занимают значительного объёма системных ресурсов.
При создании виртуального потока JVM не выделяет ему поток ОС. Вместо этого он работает как задача, которую можно приостановить, запустить и снова приостановить, не занимая поток ОС постоянно.

Java
Thread.startVirtualThread(() -> {
// код, выполняющийся в виртуальном потоке
});

Планировщик потоков JVM:
Виртуальные потоки управляются специальным планировщиком на уровне JVM, который распределяет их выполнение на реальные потоки ОС (каркасные потоки, "carrier threads").
Планировщик действует подобно планировщикам ОС, но в пределах JVM, что позволяет более гибко управлять приостановкой и возобновлением виртуальных потоков.

Блокирующие операции и приостановка:
При выполнении блокирующей операции, такой как I/O или sleep, виртуальный поток автоматически приостанавливается JVM и освобождает ресурс каркасного потока.
При этом происходит переключение контекста, при котором виртуальный поток освобождает каркасный поток. Этот процесс значительно быстрее и менее ресурсоёмкий, чем работа с потоками ОС.
При завершении блокирующей операции виртуальный поток снова ставится в очередь для выполнения на одном из каркасных потоков.

Возобновление виртуального потока:
Когда блокирующая операция завершается, виртуальный поток снова назначается на выполнение и подхватывается каркасным потоком.
Это позволяет JVM выполнять сотни тысяч виртуальных потоков с ограниченным количеством потоков ОС, обеспечивая масштабируемость.

Управление стэком:
Одной из главных задач в реализации Project Loom было создание лёгких виртуальных потоков с поддержкой приостановки и возобновления, что потребовало модификаций стека.
При приостановке виртуального потока JVM сохраняет стек вызовов этого потока, что позволяет возобновить выполнение потока позже, как будто он никогда не приостанавливался.

Эффективное использование ресурсов:
Поскольку виртуальные потоки не привязаны к потокам ОС, JVM может запускать тысячи виртуальных потоков, используя всего несколько каркасных потоков.
Это позволяет эффективно использовать процессорное время и уменьшить накладные расходы, так как JVM не обращается к системным вызовам для создания новых потоков ОС.

Технические компоненты и аспекты

Виртуальные потоки (Virtual Threads):
это ключевой компонент Project Loom. Виртуальные потоки создаются и управляются JVM, а не ОС, и могут приостанавливаться и возобновляться по мере необходимости, освобождая ресурсы для других задач.

Каркасные потоки (Carrier Threads):
это потоки ОС, которые используются JVM для выполнения виртуальных потоков. JVM управляет пулом каркасных потоков, которые выполняют приостановленные виртуальные потоки.

Продвинутое управление стэком:
Loom использует копирование стека при приостановке, что позволяет сохранять текущее состояние выполнения потока и восстанавливать его при возобновлении.

Оптимизированное управление I/O:
Loom встроен в JVM таким образом, что блокирующие вызовы, такие как чтение из файлов или сетевые запросы, обрабатываются автоматически, приостанавливая виртуальные потоки до завершения I/O.

Совместимость с существующим кодом:
Виртуальные потоки выглядят как обычные потоки Thread для остальной части Java-программы, что позволяет использовать Loom с существующим кодом без изменений.

Совместимость

Project Loom поддерживается начиная с JDK 19 и далее. Виртуальные потоки появились как превью-функция в JDK 19 и 20, а в JDK 21 стали стабильной функцией. Проект Loom разрабатывается в рамках OpenJDK, поэтому его поддержка доступна только на JVM, совместимых с OpenJDK.

JDK 8 - JDK 18:
На этих версиях виртуальные потоки Loom не поддерживаются и не могут быть активированы. Для этих версий Java придётся использовать альтернативные подходы для асинхронного программирования, такие как стандартные потоки, CompletableFuture, RxJava, Kotlin корутины и другие.

Сторонние реализации JVM на базе JDK 8-18:
Даже если это реализация от стороннего вендора (например, Amazon Corretto, GraalVM, Zulu и т. д.), если она основана на JDK 8-18, то поддержка виртуальных потоков Project Loom также будет отсутствовать.

JDK 19 и 20:
Loom доступен для использования начиная с этой версии, но как превью, что требует явного включения флага для активации виртуальных потоков.

JDK 21 и выше:
начиная с этой версии виртуальные потоки — стабильная функция, флаг включения превью не нужен.

JVM от OpenJDK:
Project Loom разрабатывается в рамках OpenJDK, так что все реализации JVM, основанные на OpenJDK (например, Zulu, AdoptOpenJDK и другие), тоже поддерживают виртуальные потоки, если они используют JDK 19+.

Не-OpenJDK JVM:
Если JVM не основана на OpenJDK (например, IBM J9 или другие проприетарные реализации), поддержка Project Loom не гарантируется, даже если версия соответствует JDK 19 или выше. Такие JVM, вероятнее всего, не включат Loom, поскольку этот проект специфичен для OpenJDK и зависит от его внутренней реализации.

GraalVM:
GraalVM на базе OpenJDK 19+ поддерживает Project Loom, если используется OpenJDK-совместимая конфигурация. Однако, если это специализированная версия GraalVM, которая не полностью совместима с OpenJDK (например, Native Image), поддержка может быть ограничена или отсутствовать.

Проприетарные сборки, несовместимые с OpenJDK:
Некоторые специализированные сборки JVM могут не включать все функции, доступные в OpenJDK 19+, так что поддержка Loom также будет отсутствовать.

Отличия от Kotlin Coroutines

Модель исполнения:

Project Loom:
виртуальные потоки в Loom реализуются на уровне JVM. Они функционируют как легковесные потоки, и JVM самостоятельно управляет их планированием. Это делает Loom ближе к традиционной модели блокирующего выполнения, но без затрат на создание полноценного потока для каждой задачи.

Kotlin Coroutines:
работают на уровне библиотеки и используют систему приостановки и возобновления для создания асинхронного кода. Управление корутинами происходит за счёт компиляции, где точки приостановки обозначаются при помощи suspend.

Поддержка и интеграция:

Project Loom:
это нативное решение JVM, что означает, что любая библиотека или код, использующий блокирующие вызовы, будет поддерживать виртуальные потоки без изменений.

Kotlin Coroutines:
работают исключительно в Kotlin и требуют написания асинхронного кода с использованием suspend функций и других корутинных конструкций.

Семантика и блокировка:

Project Loom:
можно использовать "блокирующий" код с виртуальными потоками без существенных затрат на производительность.

Kotlin Coroutines:
код должен быть написан с учётом асинхронности, используя suspend и await, что требует иногда перестройки привычных синхронных алгоритмов.

Производительность:

Project Loom:
имеет преимущество на JVM, так как создаёт и управляет виртуальными потоками напрямую, что минимизирует накладные расходы по сравнению с потоками ОС.

Kotlin Coroutines:
очень производительны, так как требуют значительно меньше ресурсов для управления асинхронностью и переходами между задачами, но они реализованы на уровне компилятора и библиотеки Kotlin, а не JVM, и нуждаются в поддержке Kotlin.

Примеры и сравнение с Kotlin Coroutines

Простой пример запуска нескольких задач параллельно:

Project Loom:

Java
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
try (
var executor = Executors.newVirtualThreadPerTaskExecutor()
) {
executor.submit(() -> {
// Ожидаемый вывод: Task 1 on (имя виртуального потока по умолчанию пустое)
System.out.println("Task 1 on " + Thread.currentThread().getName());
});
executor.submit(() -> {
// Ожидаемый вывод: Task 2 on (имя виртуального потока по умолчанию пустое)
System.out.println("Task 2 on " + Thread.currentThread().getName());
});
// Ожидаемый вывод: Main task on main
System.out.println("Main task on " + Thread.currentThread().getName());
}
}
}

Kotlin Coroutines:

Kotlin
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
// Ожидаемый вывод: Task 1 on DefaultDispatcher-worker-1 (название потока может измениться)
println("Task 1 on ${Thread.currentThread().name}")
}
launch {
// Ожидаемый вывод: Task 2 on DefaultDispatcher-worker-2 (название потока может измениться)
println("Task 2 on ${Thread.currentThread().name}")
}
// Ожидаемый вывод: Main task on main
println("Main task on ${Thread.currentThread().name}")
}

Асинхронная обработка данных с ожиданием результатов:

Project Loom:

Java
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) throws Exception {
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
var result1 = executor.submit(() -> getData1());
var result2 = executor.submit(() -> getData2());
// Ожидаемый вывод: Result: 30
System.out.println("Result: " + (result1.get() + result2.get()));
}
}
public static int getData1() throws InterruptedException {
Thread.sleep(1000);
return 10;
}
public static int getData2() throws InterruptedException {
Thread.sleep(1000);
return 20;
}
}

Kotlin Coroutines:

Kotlin
import kotlinx.coroutines.*
fun main() = runBlocking {
val result1 = async { getData1() }
val result2 = async { getData2() }
// Ожидаемый вывод: Result: 30
println("Result: ${result1.await() + result2.await()}")
}
suspend fun getData1(): Int {
delay(1000)
return 10
}
suspend fun getData2(): Int {
delay(1000)
return 20
}

Использование delay в Kotlin и аналог в Java с виртуальными потоками:

Project Loom:

Java
public class Main {
public static void main(String[] args) throws InterruptedException {
var thread = Thread.startVirtualThread(() -> {
// Ожидаемый вывод: Start
System.out.println("Start");
try {
Thread.sleep(1000); // Работает как delay
} catch (InterruptedException e) {
e.printStackTrace();
}
// Ожидаемый вывод: End after 1 second
System.out.println("End after 1 second");
});
thread.join();
}
}

Kotlin Coroutines:

Kotlin
import kotlinx.coroutines.*
fun main() = runBlocking {
// Ожидаемый вывод: Start
println("Start")
delay(1000)
// Ожидаемый вывод: End after 1 second
println("End after 1 second")
}

Параллельное выполнение задач с ожиданием результата:

Project Loom:

Java
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) throws Exception {
try (
var executor = Executors.newVirtualThreadPerTaskExecutor()
) {
var tasks = List.of(
(Callable<Integer>) () -> { return getData(1); },
(Callable<Integer>) () -> { return getData(2); },
(Callable<Integer>) () -> { return getData(3); }
);
var results = executor.invokeAll(tasks)
.stream()
.map(future -> {
try {
return future.get();
} catch (Exception e) {
throw new RuntimeException(e);
}
})
.toList();
// Ожидаемый вывод: Results: [10, 20, 30]
System.out.println("Results: " + results);
}
}
public static int getData(int id) throws InterruptedException {
Thread.sleep(500);
return id * 10;
}
}

Kotlin Coroutines:

Kotlin
import kotlinx.coroutines.*
fun main() = runBlocking {
val results = listOf(
async { getData(1) },
async { getData(2) },
async { getData(3) }
).awaitAll()
// Ожидаемый вывод: Results: [10, 20, 30]
println("Results: $results")
}
suspend fun getData(id: Int): Int {
delay(500)
return id * 10
}

Использование каналов для обмена данными:

Project Loom:

Java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
public class Main {
public static void main(String[] args) throws InterruptedException {
var queue = new LinkedBlockingQueue<Integer>();
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
executor.submit(() -> {
for (int i = 1; i <= 5; i++) {
queue.put(i * i);
}
// Специальное значение для завершения
queue.put(-1);
});
int value;
while ((value = queue.take()) != -1) {
// Ожидаемый вывод: 1, 4, 9, 16, 25 (каждое число с новой строки)
System.out.println(value);
}
}
}
}

Kotlin Coroutines:

Kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel
fun main() = runBlocking {
val channel = Channel<Int>()
launch {
for (x in 1..5) channel.send(x * x)
channel.close()
}
for (y in channel)
// Ожидаемый вывод: 1, 4, 9, 16, 25 (каждое число с новой строки)
println(y)
}

Ради разнообразия - несколько примеров на Kotlin с использованием Project Loom, чтобы показать, что так также можно

Выполнение нескольких HTTP-запросов:
Предположим, у вас есть несколько API, к которым нужно обратиться параллельно. Вот как можно сделать это с помощью виртуальных потоков.

Kotlin
import java.net.HttpURLConnection
import java.net.URL
import java.util.concurrent.Executors
fun main() {
val urls = listOf(
"https://jsonplaceholder.typicode.com/posts/1",
"https://jsonplaceholder.typicode.com/posts/2",
"https://jsonplaceholder.typicode.com/posts/3"
)
val executor = Executors.newVirtualThreadPerTaskExecutor()
try {
val tasks = urls.map { url ->
executor.submit {
fetchUrl(url)
}
}
// Ожидаем завершения всех задач
tasks.forEach { it.get() }
} finally {
executor.close()
}
}
fun fetchUrl(urlString: String) {
val url = URL(urlString)
val connection = url.openConnection() as HttpURLConnection
connection.requestMethod = "GET"
val responseCode = connection.responseCode
println("Response Code for $urlString: $responseCode")
connection.inputStream.use { inputStream ->
val response = inputStream.bufferedReader().readText()
// Печатаем первые 100 символов
println("Response Body for $urlString: ${response.take(100)}")
}
}

Параллельное выполнение вычислений:
В этом примере мы будем выполнять несколько вычислений параллельно.

Kotlin
import java.util.concurrent.Executors
fun main() {
val executor = Executors.newVirtualThreadPerTaskExecutor()
try {
val tasks = List(5) { i ->
executor.submit {
val result = heavyComputation(i)
println("Result of computation $i: $result on thread: ${Thread.currentThread().name}")
}
}
// Ожидаем завершения всех задач
tasks.forEach { it.get() }
} finally {
executor.close()
}
}
fun heavyComputation(n: Int): Int {
// Эмуляция тяжелых вычислений
Thread.sleep(1000)
return n * n
}

Работа с потоками ввода-вывода:
Этот пример демонстрирует, как виртуальные потоки могут помочь упростить работу с потоками ввода-вывода.

Kotlin
import java.io.File
import java.util.concurrent.Executors
fun main() {
val fileNames = listOf("file1.txt", "file2.txt", "file3.txt")
val executor = Executors.newVirtualThreadPerTaskExecutor()
try {
val tasks = fileNames.map { fileName ->
executor.submit {
readFile(fileName)
}
}
// Ожидаем завершения всех задач
tasks.forEach { it.get() }
} finally {
executor.close()
}
}
fun readFile(fileName: String) {
try {
val content = File(fileName).readText()
// Печатаем первые 50 символов
println("Content of $fileName: ${content.take(50)}")
} catch (e: Exception) {
println("Failed to read $fileName: ${e.message}")
}
}

Масштабируемый веб-сервер на виртуальных потоках:
Здесь мы создаем простой HTTP-сервер, который использует виртуальные потоки для обработки каждого запроса. Это позволяет легко масштабироваться и обрабатывать большое количество запросов одновременно.

Kotlin
import java.net.ServerSocket
import java.util.concurrent.Executors
fun main() {
val port = 8080
val serverSocket = ServerSocket(port)
println("Server started on port $port")
val executor = Executors.newVirtualThreadPerTaskExecutor()
try {
while (true) {
val clientSocket = serverSocket.accept()
executor.submit {
clientSocket.use {
val request = it.getInputStream().bufferedReader().readLine()
println("Received request: $request on thread: ${Thread.currentThread().name}")
val response = """
HTTP/1.1 200 OK
Content-Type: text/plain
Hello from virtual threads!
""".trimIndent()
it.getOutputStream().apply {
write(response.toByteArray())
flush()
}
println("Response sent on thread: ${Thread.currentThread().name}")
}
}
}
} finally {
executor.close()
}
}

Интеграция Project Loom с Spring

Для интеграции Project Loom с Spring можно использовать виртуальные потоки для обработки запросов, что делает асинхронное программирование более простым и эффективным, чем традиционные потоки.

Конфигурация для Tomcat:
Мы можем настроить Tomcat для использования виртуальных потоков, указав собственный исполнитель (Executor) на виртуальных потоках.
Настройка TomcatServletWebServerFactory с этим исполнителем позволяет обрабатывать каждый запрос в виртуальном потоке, экономя ресурсы при высоконагруженной работе.

Java
import org.apache.catalina.connector.Connector;
import java.util.concurrent.Executors;
import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class TomcatLoomApplication {
@Bean
public ServletWebServerFactory servletContainer() {
TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
factory.addConnectorCustomizers(connector -> {
AbstractHttp11Protocol<?> protocol = (AbstractHttp11Protocol<?>) connector.getProtocolHandler();
// Каждый запрос обрабатывается в новом виртуальном потоке
protocol.setExecutor(Executors.newThreadPerTaskExecutor(
Thread.ofVirtual().name("loom-thread-", 0).factory()));
});
return factory;
}
public static void main(String[] args) {
SpringApplication.run(TomcatLoomApplication.class, args);
}
}

Конфигурация для Jetty:
Для настройки виртуальных потоков в Jetty мы настраиваем ThreadPool так, чтобы запросы выполнялись в виртуальных потоках.
Использование QueuedThreadPool с исполнителем виртуальных потоков позволяет Jetty масштабироваться и создавать потоки по мере необходимости без затрат на системные потоки.

Java
import java.util.concurrent.Executors;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class JettyLoomApplication {
@Bean
public ServletWebServerFactory servletContainer() {
JettyServletWebServerFactory factory = new JettyServletWebServerFactory();
factory.addServerCustomizers(server -> {
QueuedThreadPool threadPool = (QueuedThreadPool) server.getThreadPool();
threadPool.setName("loom-thread-");
// Запросы выполняются в виртуальных потоках
threadPool.setVirtualThreadsExecutor(Executors.newThreadPerTaskExecutor(
Thread.ofVirtual().name("loom-thread-", 0).factory()));
});
return factory;
}
public static void main(String[] args) {
SpringApplication.run(JettyLoomApplication.class, args);
}
}

Конфигурация для Undertow:
Для работы с виртуальными потоками в Undertow мы задаем для сервлетов исполнитель на виртуальных потоках.
В Undertow создается XnioWorker для ввода-вывода, а сервлеты выполняются исполнителем на виртуальных потоках. Это подходит для асинхронной обработки запросов и неблокирующей архитектуры Undertow.

Java
import io.undertow.UndertowOptions;
import java.io.IOException;
import java.util.concurrent.Executors;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.xnio.OptionMap;
import org.xnio.Options;
import org.xnio.Xnio;
import org.xnio.XnioWorker;
@SpringBootApplication
public class UndertowLoomApplication {
@Bean
public ServletWebServerFactory servletContainer() throws IOException {
XnioWorker worker = createWorker();
UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();
factory.addBuilderCustomizers(builder -> {
builder.setWorker(worker);
builder.setServerOption(UndertowOptions.ENABLE_HTTP2, true);
});
// Сервлеты выполняются в виртуальных потоках
factory.addDeploymentInfoCustomizers(deploymentInfo -> deploymentInfo.setExecutor(
Executors.newThreadPerTaskExecutor(Thread.ofVirtual().name("loom-thread-", 0).factory())));
return factory;
}
private XnioWorker createWorker() throws IOException {
Xnio xnio = Xnio.getInstance();
return xnio.createWorker(OptionMap.builder()
.set(Options.THREAD_DAEMON, false)
.set(Options.WORKER_IO_THREADS, 4)
.set(Options.WORKER_TASK_CORE_THREADS, 10)
.getMap()
);
}
public static void main(String[] args) {
SpringApplication.run(UndertowLoomApplication.class, args);
}
}

Начиная со Spring Boot 3.2 и JDK 21 виртуальные потоки можно включить одним встроенным свойством spring.threads.virtual.enabled=true в application.properties или application.yml. В более ранних версиях Spring Boot настройка кастомного ThreadFactory и изменение структуры пула потоков встроенными свойствами не поддерживались.

Тем не менее, существуют альтернативные способы настройки виртуальных потоков без необходимости явно писать код настройки в @Bean. Например, можно создать собственную @Configuration для более централизованного управления.

Подход с кастомной конфигурацией на основе свойства:
Можно создать кастомную конфигурацию, чтобы при включении определенного свойства в application.properties, Spring автоматически применял настройки виртуальных потоков.
Добавим кастомное свойство в application.properties:

Properties
server.use-virtual-threads=true

Создадим конфигурационный класс, который проверяет значение свойства и применяет настройки для выбранного сервера (например, Tomcat).
В данном примере настройка server.use-virtual-threads=true активирует конфигурацию с виртуальными потоками, если это свойство установлено в application.properties. Это позволяет переключать использование виртуальных потоков через конфигурацию, не изменяя код приложения.

Java
import org.apache.catalina.connector.Connector;
import java.util.concurrent.Executors;
import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class VirtualThreadConfig {
@Value("${server.use-virtual-threads:false}")
private boolean useVirtualThreads;
@Bean
@ConditionalOnProperty(name = "server.use-virtual-threads", havingValue = "true")
public ServletWebServerFactory servletContainer() {
TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
factory.addConnectorCustomizers(connector -> {
AbstractHttp11Protocol<?> protocol = (AbstractHttp11Protocol<?>) connector.getProtocolHandler();
// Каждый запрос обрабатывается в новом виртуальном потоке
protocol.setExecutor(Executors.newThreadPerTaskExecutor(
Thread.ofVirtual().name("loom-thread-", 0).factory()));
});
return factory;
}
}

Использование WebServerFactoryCustomizer для дополнительной гибкости:
Другой способ — создать WebServerFactoryCustomizer, который проверяет свойства и применяет виртуальные потоки, если это включено. Этот способ позволяет гибко настраивать сервер, не создавая собственную фабрику. Настройка должна выполняться до запуска сервера, поэтому CommandLineRunner и ApplicationRunner здесь не подходят: они вызываются, когда сервер уже запущен, и изменения в фабрике ни на что не влияют.
Для активации этого подхода можно установить свойство -Dserver.use-virtual-threads=true при запуске Spring Boot приложения.

Java
import java.util.concurrent.Executors;
import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.stereotype.Component;
@Component
public class VirtualThreadCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
@Override
public void customize(TomcatServletWebServerFactory factory) {
boolean useVirtualThreads = Boolean.parseBoolean(System.getProperty("server.use-virtual-threads", "false"));
if (useVirtualThreads) {
factory.addConnectorCustomizers(connector -> {
AbstractHttp11Protocol<?> protocol = (AbstractHttp11Protocol<?>) connector.getProtocolHandler();
// Каждый запрос обрабатывается в новом виртуальном потоке
protocol.setExecutor(Executors.newThreadPerTaskExecutor(
Thread.ofVirtual().name("loom-thread-", 0).factory()));
});
}
}
}

Продолжение следует (планирую добавить еще примеры и сравнение производительности)

Copyright: Roman Kryvolapov