[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$f1b300lqgtfmoj":3,"$f250wz8h39yydc":8,"$f3e13fn86h0z0l":29,"$f1tmzc20p7l0cb":37,"$f1upybnaolgiro":72,"toc--164009262-5-5":76},{"description":4,"domain":5,"id":6,"keywords":4,"title":7},"","api.kongjs.com",1,"默认",[9,20,24],{"children":10,"icon":4,"id":11,"linkType":12,"linkUrl":13,"parentId":14,"sort":15,"status":16,"target":17,"title":18,"visible":19},null,"447369447469600768","URL","\u002F","0",0,"1","_self","首页",true,{"children":10,"icon":4,"id":21,"linkType":12,"linkUrl":22,"parentId":14,"sort":15,"status":16,"target":17,"title":23,"visible":19},"447369693859794944","\u002Fnotes","笔记",{"children":10,"icon":4,"id":25,"linkType":26,"linkUrl":27,"parentId":14,"sort":15,"status":16,"target":17,"title":28,"visible":19},"447369977960976384","PAGE","\u002Fabout","关于我",{"category":30,"categoryId":31,"cover":10,"description":4,"fileId":10,"id":34,"publishAt":10,"tags":35,"title":36},{"articleCount":10,"children":10,"cover":10,"description":4,"fileId":10,"icon":4,"id":31,"parentId":14,"slug":32,"sort":15,"title":33},"453164732518506496","back-end","后端","453165633773772800",[],"Java面试核心知识",[38,41,44,48,52,56,60,64,68],{"children":10,"description":4,"id":39,"noteId":34,"parentId":14,"sort":15,"status":16,"title":40},"453165775620939776","Java基础核心全集（数据类型、拆箱装箱、克隆、对象结构、字符串、包装类、序列化）",{"children":10,"description":4,"id":42,"noteId":34,"parentId":14,"sort":6,"status":16,"title":43},"453166088570544128","JVM原理（JDK8~25）内存结构、分代模型、GC算法、垃圾收集器、元空间、双亲委派机制",{"children":10,"description":4,"id":45,"noteId":34,"parentId":14,"sort":46,"status":16,"title":47},"453166295265845248",2,"Java8至25 对象创建全过程及各版本底层演进差异",{"children":10,"description":4,"id":49,"noteId":34,"parentId":14,"sort":50,"status":16,"title":51},"453166545573519360",3,"Java集合全套原理（List+Map底层、扩容机制、线程安全集合对比）",{"children":10,"description":4,"id":53,"noteId":34,"parentId":14,"sort":54,"status":16,"title":55},"453166809651093504",4,"Java线程原理、六大状态流转、线程结束判断、安全中断、核心方法区别",{"children":10,"description":4,"id":57,"noteId":34,"parentId":14,"sort":58,"status":16,"title":59},"453167023724175360",5,"Java线程池原理、使用规范、常用并发异步工具类",{"children":10,"description":4,"id":61,"noteId":34,"parentId":14,"sort":62,"status":16,"title":63},"453167209447956480",6,"Java 虚拟线程与平台线程：原理、区别与实战使用",{"children":10,"description":4,"id":65,"noteId":34,"parentId":14,"sort":66,"status":16,"title":67},"453167452423987200",7,"CAS与AQS 底层原理、核心流程、面试最全详解",{"children":10,"description":4,"id":69,"noteId":34,"parentId":14,"sort":70,"status":16,"title":71},"453168570885480448",8,"线上服务器CPU飙升 Java代码 完整定位排查流程",{"content":73,"contentType":74,"description":4,"title":63,"wordCount":75},"# Java 虚拟线程与平台线程：原理、区别与实战使用\n\nJava 线程分为**平台线程（Platform Thread）**和**虚拟线程（Virtual Thread）**两类。平台线程是JDK传统线程实现，而虚拟线程是 **JDK21（JEP444）正式转正**、源自Project Loom的轻量级线程，彻底解决了传统线程高并发资源受限、线程池冗余编码的问题。二者均为 `java.lang.Thread` 的子类，API完全兼容，但底层调度、资源模型、使用场景天差地别。\n\n## 一、核心原理详解\n\n### 1\\. 平台线程（传统线程）原理\n\n平台线程是**操作系统内核线程 1:1 映射**的重量级线程，是Java长期以来的默认线程实现。\n\n**底层机制**：每创建一个Java平台线程，JVM都会向操作系统申请一个真实的OS内核线程，线程的生命周期（创建、调度、阻塞、销毁）完全由操作系统内核管理。\n\n**核心特性**：\n\n- **固定资源占用**：默认栈内存 1MB 左右，线程创建即分配固定栈空间，无法动态伸缩，大量创建会直接耗尽堆外内存，触发OOM\n\n- **内核级调度**：线程切换、时间片分配由操作系统内核完成，上下文切换成本高\n\n- **阻塞固化**：线程触发IO、锁等待阻塞时，对应的OS线程会被内核挂起，全程占用系统资源，无法复用\n\n- **数量受限**：受限于操作系统最大线程数，单机通常仅能创建数千个平台线程，高并发场景必须依赖线程池复用\n\n简单来说：平台线程的瓶颈在**操作系统**，是系统级的重量级资源。\n\n### 2\\. 虚拟线程（Virtual Thread）原理\n\n虚拟线程是**JVM用户态管理的轻量级线程**，打破了OS线程1:1绑定的限制，采用 **N:M 调度模型**（多个虚拟线程复用少量平台线程）。\n\n**底层核心机制**：\n\n- **载体线程（Carrier Thread）**：JVM维护一个全局平台线程池作为载体，所有虚拟线程的执行都依托载体线程完成，载体线程数量极少，默认与CPU核心数匹配\n\n- **动态栈伸缩**：虚拟线程初始栈仅几KB，栈内存按需扩容、缩容，闲置时自动释放，无固定内存占用\n\n- **JVM层调度**：线程的切换、挂起、唤醒由JVM runtime自主管理，无需内核介入，上下文切换成本极低\n\n- **阻塞不占载体**：虚拟线程触发IO、锁阻塞时，**不会挂起载体线程**，JVM会将虚拟线程挂起并保存上下文，载体线程立即复用执行其他虚拟任务，彻底消除阻塞资源浪费\n\n简单来说：虚拟线程的瓶颈在**JVM**，单机可轻松支撑百万级虚拟线程，是应用层的轻量化并发单元。\n\n## 二、平台线程与虚拟线程核心区别\n\n从底层调度、资源开销、并发能力、适用场景等多维度对比，核心差异一目了然：\n\n|对比维度|平台线程（Platform Thread）|虚拟线程（Virtual Thread）|\n|---|---|---|\n|调度模型|1:1 绑定OS内核线程，内核调度|N:M 映射载体线程，JVM用户态调度|\n|内存开销|高，默认固定1MB栈内存|极低，初始几KB，动态伸缩|\n|线程数量上限|数千级（系统限制）|百万级（JVM支持）|\n|阻塞表现|阻塞时OS线程挂起，资源闲置浪费|阻塞时释放载体线程，载体可复用|\n|上下文切换成本|高（内核态切换）|极低（用户态JVM切换）|\n|线程池依赖|必须依赖线程池复用，否则性能极差|无需线程池，随用随创建、用完即销毁|\n|生命周期管理|操作系统内核管理|JVM runtime 自主管理|\n|版本支持|所有JDK版本默认支持|JDK21\\+ 正式支持|\n|最佳场景|CPU密集型任务、长驻后台任务|IO密集型、短耗时、高并发请求任务|\n\n## 三、实战使用方式（JDK21\\+）\n\n虚拟线程完全兼容传统Thread API，无需修改原有线程业务逻辑，仅创建方式不同，上手成本极低。同时官方明确：**虚拟线程不建议手动池化，自带轻量化特性，随开随用最优**。\n\n### 1\\. 平台线程常规使用（传统方式）\n\n传统平台线程需手动创建或通过线程池复用，高并发下必须池化，否则频繁创建销毁线程开销巨大：\n\n```java\n\u002F\u002F 1. 原生平台线程创建\npublic class PlatformThreadDemo {\n    public static void main(String[] args) {\n        \u002F\u002F 默认创建的就是平台线程\n        Thread platformThread = new Thread(() -> {\n            System.out.println(\"平台线程执行任务：\" + Thread.currentThread().getName());\n        });\n        platformThread.start();\n    }\n}\n\n\u002F\u002F 2. 业务常用：线程池复用平台线程（高并发必备）\nimport java.util.concurrent.Executors;\npublic class PlatformThreadPoolDemo {\n    public static void main(String[] args) {\n        \u002F\u002F 固定大小线程池，限制平台线程数量，避免资源耗尽\n        try (var executor = Executors.newFixedThreadPool(10)) {\n            for (int i = 0; i \u003C 100; i++) {\n                executor.submit(() -> {\n                    \u002F\u002F 模拟IO任务\n                    System.out.println(\"线程池平台线程执行：\" + Thread.currentThread().getName());\n                });\n            }\n        }\n    }\n}\n```\n\n### 2\\. 虚拟线程实战使用（三种常用方式）\n\n#### 方式1：Thread\\.ofVirtual\\(\\) 手动创建（简洁直观）\n\n```java\npublic class VirtualThreadDemo {\n    public static void main(String[] args) throws InterruptedException {\n        \u002F\u002F 创建并启动虚拟线程（JDK21+）\n        Thread virtualThread = Thread.ofVirtual()\n                .name(\"virtual-thread-1\")\n                .start(() -> {\n                    System.out.println(\"虚拟线程执行任务：\" + Thread.currentThread().getName());\n                    System.out.println(\"是否虚拟线程：\" + Thread.currentThread().isVirtual());\n                });\n\n        virtualThread.join(); \u002F\u002F 等待虚拟线程执行完成\n    }\n}\n```\n\n#### 方式2：Executors\\.newVirtualThreadPerTaskExecutor\\(\\)（业务首选）\n\n官方推荐业务开发使用，为每个任务自动创建一个虚拟线程，自动管理生命周期，无需手动池化，完美适配请求 per\\-task 模型：\n\n```java\nimport java.util.concurrent.Executors;\n\npublic class VirtualThreadExecutorDemo {\n    public static void main(String[] args) {\n        \u002F\u002F 虚拟线程执行器：每个任务独立一个虚拟线程，无数量上限限制\n        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n            \u002F\u002F 轻松支持10000+并发任务，无OOM风险\n            for (int i = 0; i \u003C 10000; i++) {\n                int taskId = i;\n                executor.submit(() -> {\n                    \u002F\u002F 模拟接口请求、数据库IO、网络调用等阻塞任务\n                    System.out.printf(\"虚拟线程任务%d执行，线程是否虚拟：%s%n\", taskId, Thread.currentThread().isVirtual());\n                    try {\n                        Thread.sleep(100); \u002F\u002F 模拟阻塞，虚拟线程阻塞不占用载体资源\n                    } catch (InterruptedException e) {\n                        Thread.currentThread().interrupt();\n                    }\n                });\n            }\n        } \u002F\u002F try-with-resources 自动关闭执行器，等待所有任务完成\n    }\n}\n```\n\n#### 方式3：批量创建虚拟线程\n\n```java\npublic class BatchVirtualThreadDemo {\n    public static void main(String[] args) {\n        for (int i = 0; i \u003C 50000; i++) {\n            int idx = i;\n            Thread.ofVirtual().start(() -> {\n                System.out.println(\"批量虚拟线程任务：\" + idx);\n            });\n        }\n    }\n}\n```\n\n## 四、适用场景与核心避坑点\n\n### 1\\. 虚拟线程适用场景（优势场景）\n\n- **IO密集型高并发业务**：HTTP接口请求、数据库查询、Redis\u002F网络调用、文件读写等大部分时间处于阻塞等待的任务\n\n- **短耗时、多并发任务**：微服务接口、网关请求、批量异步处理等短生命周期任务\n\n- **无需线程池调优的场景**：彻底告别核心线程数、最大线程数、队列、拒绝策略等线程池参数调优\n\n### 2\\. 虚拟线程不适用场景（劣势场景）\n\n- **纯CPU密集型任务**：虚拟线程依托载体线程执行，CPU密集型任务会长期占用载体线程，无法发挥N:M调度优势，性能不如平台线程\n\n- **长驻后台线程**：定时任务、常驻监控线程等长期运行不阻塞的任务，推荐使用平台线程\n\n- **大量同步锁竞争任务**：虚拟线程在synchronized锁阻塞时，JVM暂无法完全释放载体线程，竞争激烈时性能下降\n\n### 3\\. 核心避坑注意事项\n\n- **禁止池化虚拟线程**：虚拟线程本身轻量、无创建开销，手动池化完全多余，会丧失其核心优势\n\n- **避免在虚拟线程中使用ThreadLocal滥用**：百万级虚拟线程若大量使用ThreadLocal，会造成内存堆积，建议使用ScopedValue替代\n\n- **synchronized锁慎用**：相比Lock锁，虚拟线程在synchronized阻塞时无法释放载体，高并发锁竞争场景优先使用ReentrantLock\n\n- **不兼容旧JDK**：虚拟线程仅JDK21及以上LTS版本支持，低版本无法使用\n\n## 五、总结\n\n1\\. **平台线程**：OS内核级重量级线程，1:1调度，内存开销大、数量受限，适合CPU密集、长驻任务，依赖线程池实现高并发；\n\n2\\. **虚拟线程**：JVM用户态轻量级线程，N:M调度、动态栈、阻塞自适应，百万级并发无压力，**是IO密集型业务的最优解**；\n\n3\\. 未来Java并发编程范式：**IO业务用虚拟线程，CPU业务用平台线程**，彻底告别传统线程池调优难题。","markdown",5377,{"frontmatter":77,"meta":78,"nodes":130},{},{"title":63,"description":79,"toc":80},"Java 线程分为**平台线程（Platform Thread）和虚拟线程（Virtual Thread）**两类。平台线程是JDK传统线程实现，而虚拟线程是 JDK21（JEP444）正式转正、源自Project Loom的轻量级线程，彻底解决了传统线程高并发资源受限、线程池冗余编码的问题。二者均为 java.lang.Thread 的子类，API完全兼容，但底层调度、资源模型、使用场景天差地别。",{"title":4,"searchDepth":58,"depth":58,"links":81},[82,91,94,114,127],{"id":4,"depth":46,"text":83,"children":84},"一、核心原理详解",[85,88],{"id":86,"depth":50,"text":87},"-_1","1. 平台线程（传统线程）原理",{"id":89,"depth":50,"text":90},"-_2-virtual-thread","2. 虚拟线程（Virtual Thread）原理",{"id":92,"depth":46,"text":93},"-1","二、平台线程与虚拟线程核心区别",{"id":95,"depth":46,"text":96,"children":97},"jdk21","三、实战使用方式（JDK21+）",[98,101],{"id":99,"depth":50,"text":100},"jdk21-_1","1. 平台线程常规使用（传统方式）",{"id":102,"depth":50,"text":103,"children":104},"jdk21-_2","2. 虚拟线程实战使用（三种常用方式）",[105,108,111],{"id":106,"depth":54,"text":107},"jdk21-_2-_1threadofvirtual","方式1：Thread.ofVirtual() 手动创建（简洁直观）",{"id":109,"depth":54,"text":110},"jdk21-_2-_2executorsnewvirtualthreadpertaskexecutor","方式2：Executors.newVirtualThreadPerTaskExecutor()（业务首选）",{"id":112,"depth":54,"text":113},"jdk21-_2-_3","方式3：批量创建虚拟线程",{"id":115,"depth":46,"text":116,"children":117},"-2","四、适用场景与核心避坑点",[118,121,124],{"id":119,"depth":50,"text":120},"-_1-1","1. 虚拟线程适用场景（优势场景）",{"id":122,"depth":50,"text":123},"-_2","2. 虚拟线程不适用场景（劣势场景）",{"id":125,"depth":50,"text":126},"-_3","3. 核心避坑注意事项",{"id":128,"depth":46,"text":129},"-3","五、总结",[131,135,153,156,159,166,172,178,206,213,215,226,231,261,268,270,273,395,397,404,406,409,416,418,421,426,428,431,436,438,443,445,447,467,469,489,491,517,519,526,537],[132,133,63],"h1",{"id":134},"java",[136,137,138,139,143,144,147,148,152],"p",{},"Java 线程分为**平台线程（Platform Thread）",[140,141,142],"strong",{},"和","虚拟线程（Virtual Thread）**两类。平台线程是JDK传统线程实现，而虚拟线程是 ",[140,145,146],{},"JDK21（JEP444）正式转正","、源自Project Loom的轻量级线程，彻底解决了传统线程高并发资源受限、线程池冗余编码的问题。二者均为 ",[149,150,151],"code",{},"java.lang.Thread"," 的子类，API完全兼容，但底层调度、资源模型、使用场景天差地别。",[154,155,83],"h2",{"id":4},[157,158,87],"h3",{"id":86},[136,160,161,162,165],{},"平台线程是",[140,163,164],{},"操作系统内核线程 1:1 映射","的重量级线程，是Java长期以来的默认线程实现。",[136,167,168,171],{},[140,169,170],{},"底层机制","：每创建一个Java平台线程，JVM都会向操作系统申请一个真实的OS内核线程，线程的生命周期（创建、调度、阻塞、销毁）完全由操作系统内核管理。",[136,173,174,177],{},[140,175,176],{},"核心特性","：",[179,180,181,188,194,200],"ul",{},[182,183,184,187],"li",{},[140,185,186],{},"固定资源占用","：默认栈内存 1MB 左右，线程创建即分配固定栈空间，无法动态伸缩，大量创建会直接耗尽堆外内存，触发OOM",[182,189,190,193],{},[140,191,192],{},"内核级调度","：线程切换、时间片分配由操作系统内核完成，上下文切换成本高",[182,195,196,199],{},[140,197,198],{},"阻塞固化","：线程触发IO、锁等待阻塞时，对应的OS线程会被内核挂起，全程占用系统资源，无法复用",[182,201,202,205],{},[140,203,204],{},"数量受限","：受限于操作系统最大线程数，单机通常仅能创建数千个平台线程，高并发场景必须依赖线程池复用",[136,207,208,209,212],{},"简单来说：平台线程的瓶颈在",[140,210,211],{},"操作系统","，是系统级的重量级资源。",[157,214,90],{"id":89},[136,216,217,218,221,222,225],{},"虚拟线程是",[140,219,220],{},"JVM用户态管理的轻量级线程","，打破了OS线程1:1绑定的限制，采用 ",[140,223,224],{},"N:M 调度模型","（多个虚拟线程复用少量平台线程）。",[136,227,228,177],{},[140,229,230],{},"底层核心机制",[179,232,233,239,245,251],{},[182,234,235,238],{},[140,236,237],{},"载体线程（Carrier Thread）","：JVM维护一个全局平台线程池作为载体，所有虚拟线程的执行都依托载体线程完成，载体线程数量极少，默认与CPU核心数匹配",[182,240,241,244],{},[140,242,243],{},"动态栈伸缩","：虚拟线程初始栈仅几KB，栈内存按需扩容、缩容，闲置时自动释放，无固定内存占用",[182,246,247,250],{},[140,248,249],{},"JVM层调度","：线程的切换、挂起、唤醒由JVM runtime自主管理，无需内核介入，上下文切换成本极低",[182,252,253,256,257,260],{},[140,254,255],{},"阻塞不占载体","：虚拟线程触发IO、锁阻塞时，",[140,258,259],{},"不会挂起载体线程","，JVM会将虚拟线程挂起并保存上下文，载体线程立即复用执行其他虚拟任务，彻底消除阻塞资源浪费",[136,262,263,264,267],{},"简单来说：虚拟线程的瓶颈在",[140,265,266],{},"JVM","，单机可轻松支撑百万级虚拟线程，是应用层的轻量化并发单元。",[154,269,93],{"id":92},[136,271,272],{},"从底层调度、资源开销、并发能力、适用场景等多维度对比，核心差异一目了然：",[274,275,276,292],"table",{},[277,278,279],"thead",{},[280,281,282,286,289],"tr",{},[283,284,285],"th",{},"对比维度",[283,287,288],{},"平台线程（Platform Thread）",[283,290,291],{},"虚拟线程（Virtual Thread）",[293,294,295,307,318,329,340,351,362,373,384],"tbody",{},[280,296,297,301,304],{},[298,299,300],"td",{},"调度模型",[298,302,303],{},"1:1 绑定OS内核线程，内核调度",[298,305,306],{},"N:M 映射载体线程，JVM用户态调度",[280,308,309,312,315],{},[298,310,311],{},"内存开销",[298,313,314],{},"高，默认固定1MB栈内存",[298,316,317],{},"极低，初始几KB，动态伸缩",[280,319,320,323,326],{},[298,321,322],{},"线程数量上限",[298,324,325],{},"数千级（系统限制）",[298,327,328],{},"百万级（JVM支持）",[280,330,331,334,337],{},[298,332,333],{},"阻塞表现",[298,335,336],{},"阻塞时OS线程挂起，资源闲置浪费",[298,338,339],{},"阻塞时释放载体线程，载体可复用",[280,341,342,345,348],{},[298,343,344],{},"上下文切换成本",[298,346,347],{},"高（内核态切换）",[298,349,350],{},"极低（用户态JVM切换）",[280,352,353,356,359],{},[298,354,355],{},"线程池依赖",[298,357,358],{},"必须依赖线程池复用，否则性能极差",[298,360,361],{},"无需线程池，随用随创建、用完即销毁",[280,363,364,367,370],{},[298,365,366],{},"生命周期管理",[298,368,369],{},"操作系统内核管理",[298,371,372],{},"JVM runtime 自主管理",[280,374,375,378,381],{},[298,376,377],{},"版本支持",[298,379,380],{},"所有JDK版本默认支持",[298,382,383],{},"JDK21+ 正式支持",[280,385,386,389,392],{},[298,387,388],{},"最佳场景",[298,390,391],{},"CPU密集型任务、长驻后台任务",[298,393,394],{},"IO密集型、短耗时、高并发请求任务",[154,396,96],{"id":95},[136,398,399,400,403],{},"虚拟线程完全兼容传统Thread API，无需修改原有线程业务逻辑，仅创建方式不同，上手成本极低。同时官方明确：",[140,401,402],{},"虚拟线程不建议手动池化，自带轻量化特性，随开随用最优","。",[157,405,100],{"id":99},[136,407,408],{},"传统平台线程需手动创建或通过线程池复用，高并发下必须池化，否则频繁创建销毁线程开销巨大：",[410,411,412],"pre",{"language":134},[149,413,415],{"class":414},"language-java","\u002F\u002F 1. 原生平台线程创建\npublic class PlatformThreadDemo {\n    public static void main(String[] args) {\n        \u002F\u002F 默认创建的就是平台线程\n        Thread platformThread = new Thread(() -> {\n            System.out.println(\"平台线程执行任务：\" + Thread.currentThread().getName());\n        });\n        platformThread.start();\n    }\n}\n\n\u002F\u002F 2. 业务常用：线程池复用平台线程（高并发必备）\nimport java.util.concurrent.Executors;\npublic class PlatformThreadPoolDemo {\n    public static void main(String[] args) {\n        \u002F\u002F 固定大小线程池，限制平台线程数量，避免资源耗尽\n        try (var executor = Executors.newFixedThreadPool(10)) {\n            for (int i = 0; i \u003C 100; i++) {\n                executor.submit(() -> {\n                    \u002F\u002F 模拟IO任务\n                    System.out.println(\"线程池平台线程执行：\" + Thread.currentThread().getName());\n                });\n            }\n        }\n    }\n}",[157,417,103],{"id":102},[419,420,107],"h4",{"id":106},[410,422,423],{"language":134},[149,424,425],{"class":414},"public class VirtualThreadDemo {\n    public static void main(String[] args) throws InterruptedException {\n        \u002F\u002F 创建并启动虚拟线程（JDK21+）\n        Thread virtualThread = Thread.ofVirtual()\n                .name(\"virtual-thread-1\")\n                .start(() -> {\n                    System.out.println(\"虚拟线程执行任务：\" + Thread.currentThread().getName());\n                    System.out.println(\"是否虚拟线程：\" + Thread.currentThread().isVirtual());\n                });\n\n        virtualThread.join(); \u002F\u002F 等待虚拟线程执行完成\n    }\n}",[419,427,110],{"id":109},[136,429,430],{},"官方推荐业务开发使用，为每个任务自动创建一个虚拟线程，自动管理生命周期，无需手动池化，完美适配请求 per-task 模型：",[410,432,433],{"language":134},[149,434,435],{"class":414},"import java.util.concurrent.Executors;\n\npublic class VirtualThreadExecutorDemo {\n    public static void main(String[] args) {\n        \u002F\u002F 虚拟线程执行器：每个任务独立一个虚拟线程，无数量上限限制\n        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n            \u002F\u002F 轻松支持10000+并发任务，无OOM风险\n            for (int i = 0; i \u003C 10000; i++) {\n                int taskId = i;\n                executor.submit(() -> {\n                    \u002F\u002F 模拟接口请求、数据库IO、网络调用等阻塞任务\n                    System.out.printf(\"虚拟线程任务%d执行，线程是否虚拟：%s%n\", taskId, Thread.currentThread().isVirtual());\n                    try {\n                        Thread.sleep(100); \u002F\u002F 模拟阻塞，虚拟线程阻塞不占用载体资源\n                    } catch (InterruptedException e) {\n                        Thread.currentThread().interrupt();\n                    }\n                });\n            }\n        } \u002F\u002F try-with-resources 自动关闭执行器，等待所有任务完成\n    }\n}",[419,437,113],{"id":112},[410,439,440],{"language":134},[149,441,442],{"class":414},"public class BatchVirtualThreadDemo {\n    public static void main(String[] args) {\n        for (int i = 0; i \u003C 50000; i++) {\n            int idx = i;\n            Thread.ofVirtual().start(() -> {\n                System.out.println(\"批量虚拟线程任务：\" + idx);\n            });\n        }\n    }\n}",[154,444,116],{"id":115},[157,446,120],{"id":119},[179,448,449,455,461],{},[182,450,451,454],{},[140,452,453],{},"IO密集型高并发业务","：HTTP接口请求、数据库查询、Redis\u002F网络调用、文件读写等大部分时间处于阻塞等待的任务",[182,456,457,460],{},[140,458,459],{},"短耗时、多并发任务","：微服务接口、网关请求、批量异步处理等短生命周期任务",[182,462,463,466],{},[140,464,465],{},"无需线程池调优的场景","：彻底告别核心线程数、最大线程数、队列、拒绝策略等线程池参数调优",[157,468,123],{"id":122},[179,470,471,477,483],{},[182,472,473,476],{},[140,474,475],{},"纯CPU密集型任务","：虚拟线程依托载体线程执行，CPU密集型任务会长期占用载体线程，无法发挥N:M调度优势，性能不如平台线程",[182,478,479,482],{},[140,480,481],{},"长驻后台线程","：定时任务、常驻监控线程等长期运行不阻塞的任务，推荐使用平台线程",[182,484,485,488],{},[140,486,487],{},"大量同步锁竞争任务","：虚拟线程在synchronized锁阻塞时，JVM暂无法完全释放载体线程，竞争激烈时性能下降",[157,490,126],{"id":125},[179,492,493,499,505,511],{},[182,494,495,498],{},[140,496,497],{},"禁止池化虚拟线程","：虚拟线程本身轻量、无创建开销，手动池化完全多余，会丧失其核心优势",[182,500,501,504],{},[140,502,503],{},"避免在虚拟线程中使用ThreadLocal滥用","：百万级虚拟线程若大量使用ThreadLocal，会造成内存堆积，建议使用ScopedValue替代",[182,506,507,510],{},[140,508,509],{},"synchronized锁慎用","：相比Lock锁，虚拟线程在synchronized阻塞时无法释放载体，高并发锁竞争场景优先使用ReentrantLock",[182,512,513,516],{},[140,514,515],{},"不兼容旧JDK","：虚拟线程仅JDK21及以上LTS版本支持，低版本无法使用",[154,518,129],{"id":128},[136,520,521,522,525],{},"1. ",[140,523,524],{},"平台线程","：OS内核级重量级线程，1:1调度，内存开销大、数量受限，适合CPU密集、长驻任务，依赖线程池实现高并发；",[136,527,528,529,532,533,536],{},"2. ",[140,530,531],{},"虚拟线程","：JVM用户态轻量级线程，N:M调度、动态栈、阻塞自适应，百万级并发无压力，",[140,534,535],{},"是IO密集型业务的最优解","；",[136,538,539,540,543],{},"3. 未来Java并发编程范式：",[140,541,542],{},"IO业务用虚拟线程，CPU业务用平台线程","，彻底告别传统线程池调优难题。"]