[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"question-mnogopotochnost-chem-otlichayutsya-korutiny-virtual-threads-i-platform-threads":3},{"id":4,"slug":5,"topicId":6,"topicSlug":7,"topicName":8,"topicEmoji":9,"question":10,"answer":11,"codeLang":12,"codeSrc":12,"important":12,"commonMistakes":12,"modernUsage":12,"difficulty":13,"tags":14,"related":21,"progress":22,"seo":23},306,"chem-otlichayutsya-korutiny-virtual-threads-i-platform-threads",8,"mnogopotochnost","Многопоточность","🔀","Чем отличаются корутины, Virtual Threads и Platform Threads?","\u003C!-- grade: 5\u002F5 — отличное сравнение трёх подходов -->\n\nВсе три механизма предназначены для организации параллельного и конкурентного выполнения, но отличаются уровнем абстракции, управлением и применимостью.\n\n**Platform Threads (потоки платформы)**\n\nОбёртка над потоками ОС (kernel threads). Каждый Platform Thread = один поток ОС.\n\n```java\nThread thread = new Thread(() -> System.out.println(\"Platform Thread\"));\nthread.start();\n```\n\n- Управляются планировщиком ОС (вытесняющее планирование)\n- Стек ~1 МБ (фиксированный)\n- Создание и переключение контекста дорогие\n- Лимит — тысячи потоков на JVM\n- Подходят для CPU-bound задач\n\n**Virtual Threads (Java 21)**\n\nЛегковесные потоки, управляемые JVM. Модель M:N — множество виртуальных потоков на нескольких carrier threads.\n\n```java\nThread vThread = Thread.ofVirtual().start(() -> System.out.println(\"Virtual Thread\"));\n```\n\n- Управляются JVM (continuation-based)\n- Стек — несколько КБ, динамический рост (heap)\n- Создание и переключение — крайне дешёвые\n- Можно создать миллионы\n- При блокировке JVM «отсоединяет» от носителя\n- Полная совместимость с существующим API `Thread`\n- Подходят для IO-bound задач\n\n**Корутины (Kotlin Coroutines)**\n\nКонструкция уровня **языка Kotlin** (не JVM). Кооперативная многозадачность — приостановка в явных точках `suspend`.\n\n```kotlin\nsuspend fun fetchData(): String {\n    delay(1000) \u002F\u002F Suspend point — НЕ блокирует поток\n    return \"данные\"\n}\n\nfun main() = runBlocking {\n    launch { println(fetchData()) }\n}\n```\n\n- Кооперативное планирование (приостановка только в `suspend`-функциях)\n- Structured Concurrency встроена с самого начала\n- Не являются потоками — это приостанавливаемые вычисления\n- Потребление — несколько сотен байт\n\n**Сравнительная таблица:**\n\n| Характеристика | Platform Thread | Virtual Thread | Корутина (Kotlin) |\n|---|---|---|---|\n| Уровень | ОС | JVM | Язык (Kotlin) |\n| Планирование | Вытесняющее (ОС) | Вытесняющее (JVM) | Кооперативное |\n| Стоимость создания | ~1 мс | ~1 мкс | Очень низкая |\n| Потребление памяти | ~1 МБ | ~несколько КБ | ~сотни байт |\n| Макс. количество | Тысячи | Миллионы | Миллионы |\n| Точки переключения | Любое место | Блокирующие операции | Только `suspend` |\n| Structured Concurrency | Нет | `StructuredTaskScope` (preview) | Встроена |\n| Совместимость с Java API | Полная | Полная | Через адаптеры |\n| CPU-bound | Подходит | Не лучше Platform | `Dispatchers.Default` |\n| IO-bound | Не масштабируется | Отлично | Отлично |\n\n**Когда что использовать:**\n\n```java\n\u002F\u002F 1. CPU-bound → Platform Threads (ForkJoinPool)\nForkJoinPool pool = new ForkJoinPool(Runtime.getRuntime().availableProcessors());\npool.submit(() -> heavyComputation());\n\n\u002F\u002F 2. IO-bound (Java) → Virtual Threads\ntry (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n    executor.submit(() -> callExternalApi());\n    executor.submit(() -> queryDatabase());\n}\n```\n\n```kotlin\n\u002F\u002F 3. IO-bound (Kotlin) → Корутины\ncoroutineScope {\n    async(Dispatchers.IO) { callExternalApi() }\n    async(Dispatchers.IO) { queryDatabase() }\n}\n```\n\n**Как обрабатывается блокировка:**\n- **Virtual Thread:** JVM автоматически unmount при блокирующем вызове, прозрачно для кода.\n- **Корутина:** блокировка только в `suspend`-точках; обычный блокирующий вызов заблокирует поток диспетчера.\n\n**Ключевые различия в философии:**\n- Virtual Threads — используют существующий блокирующий API, JVM делает его неблокирующим «под капотом».\n- Корутины — новый синтаксис (`suspend`), больше контроля (диспетчеры, каналы), явные точки приостановки.\n- Kotlin-корутины могут работать поверх Virtual Threads, объединяя преимущества обоих.\n\n**Частые ошибки:**\n- Virtual Threads для CPU-bound — не даёт преимущества.\n- Блокировка в корутинах вне `Dispatchers.IO` — голодание общего пула.\n- Замена всех Platform Threads на Virtual без анализа — pinning в `synchronized`.\n\n**Тренд 2024-2026:** отказ от реактивных фреймворков (WebFlux, RxJava) в пользу Virtual Threads для новых проектов, где реактивность использовалась только ради масштабируемости IO.\n\n> **Аналогия:** Platform Thread — это курьер на автомобиле: дорогой, но выполняет любую работу. Virtual Thread — курьер на велосипеде: дешёвый, по городу (IO) быстрее, но тяжёлый груз (CPU) не потянет. Корутина — дрон: ещё легче, летает быстро, но требует специальную инфраструктуру (Kotlin runtime) и умеет приземляться только в отмеченных точках (suspend).\n\n> **На собеседовании** важно показать, что вы понимаете: это не конкурирующие, а взаимодополняющие технологии. Platform Threads — фундамент, Virtual Threads — масштабируемость IO в Java, корутины — экосистема Kotlin. Прямое сравнение производительности некорректно, так как они работают на разных уровнях.","","senior",[15,16,17,18,19,20],"корутины","Platform-Threads","сравнение","Virtual-Threads","Kotlin","concurrency",[],null,{"title":24,"description":25,"ogTitle":26,"ogDescription":27,"keywords":28,"schemaAnswer":34,"featuredSnippetReady":35},"Корутины vs Virtual Threads vs Platform Threads — сравнение — Gymterview","Platform Threads — ОС-потоки (~1 МБ, тысячи). Virtual Threads — JVM-потоки (КБ, миллионы). Корутины Kotlin — уровень языка (сотни байт, кооперативные).","Корутины, Virtual Threads, Platform Threads — что выбрать?","Platform Threads — ОС, вытесняющее планирование. Virtual Threads — JVM, автоматический unmount. Корутины Kotlin — язык, явные suspend-точки.",[29,30,31,32,33],"корутины vs Virtual Threads","Platform Threads vs Virtual Threads","Kotlin coroutines Java","сравнение потоков","кооперативная многозадачность","Platform Threads — обёртка над ОС-потоками, вытесняющее планирование, ~1 МБ стека, лимит — тысячи, для CPU-bound задач. Virtual Threads (Java 21) — управляются JVM, модель M:N, несколько КБ, миллионы, автоматический unmount при блокировке, для IO-bound. Корутины Kotlin — уровень языка, кооперативное планирование, suspend-функции, сотни байт, встроенная Structured Concurrency. Virtual Threads — ответ Java на корутины: обычный блокирующий код, который JVM делает неблокирующим.",true]