Java虚拟线程vs平台线程

翻译 已于 2024-02-13 18:54:23 修改 · 691 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：https://blog.stackademic.com/java-threading-essentials-virtual-vs-platform-threads-explained-32365d8f92be
GEO检测
收录于
Java

当前文章被收录于：

Java
5 篇文章 0 人学习
订阅专栏 查看详情
于 2024-02-01 22:23:27 首次发布
本文探讨了Java中经典线程模型的局限性，引入了虚拟线程和平台线程的概念，强调了虚拟线程在提高资源利用率和简化并发编程方面的优势。同时，指出了ThreadLocal在虚拟线程环境下的变化和可能带来的问题。

本文讨论一些关于Java线程的概念：

  • 虚拟线程 Virtual Thread
  • 平台线程 Platform Thread

将介绍虚拟线程和平台线程的本质区别以及它们如何提升级程序性能。

在这里插入图片描述

经典线程模型

当Java Web Server处理HTTP请求时：

  1. 创建Thread并准备接收请求
  2. 请求来到匹配到一个Thread，然后Thread做访问数据库的处理
  3. Thread会等待数据库返回数据
  4. 取得数据后响应请求，最后回到线程池中

在这里插入图片描述

在上面的线程生命周期中，第3步线程只是等待，不会做任何事情。这是一大缺陷，并没有充分利用系统资源。线程大多数时间只是在等待，并没有做实际的工作。

在Java19以前，创建的线程我们叫本地线程(Native Threads)或者平台线程(Platform Thread)。在这种架构方式下，平台线程和操作系统线程(OS Thread)是一对一的关系。这意味着，操作系统线程没有被充分利用。使得线程的使用很重，成本提高。

虚拟线程 (Virtual Threads)

Java的虚拟线程是多线程处理并发任务的重大改进。虚拟线程是作为 Project Loom一部分，为了编写、维护以及观察高吞吐量的并发程序而设计的。它让开发者很容易写出轻量级的并发程序。

虚拟线程是由Java Virtual Machine(JVM)管理的轻量级线程，而不是由操作系统管理。不像平台线程，虚拟线程的创建和销毁成本很低。它们会被对应到更少数量的平台线程。使Java可以使用更少的机器资源，处理成千上万、上百万的并发任务。

在这里插入图片描述

虚拟线程比平台线程更实用

虚拟线程有很多优点。首先，它可以更有效的利用操作系统资源。因为系统线程是轻量级的，与平台线程相比，消耗更少的内存和CPU资源。这使用可以在一个JVM中执行数量非常多的并发任务。

第二，虚拟线程简化了Java并发编程。它允许开发者以直接的命令式的风格编写代码，像想是在写同步的代码一样。不用处理异步编程的复杂性。这种减化也会减少BUG的出现。

而且，虚拟线程能让CPU更好的被利用。在传统的线程模型中，大量的CPU时间被浪费在大量的线程管理和切换线程的工作中，虚拟线程减少了这些浪费，让并发任务的执行更加有效。

实践

如果我们使用经典的平台线程去完成工作，我们要像下面这样编写程序：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PlatformThreadDemo {
    private static final Logger logger = LoggerFactory.getLogger(PlatformThreadDemo.class);

    public static void main(String[] args) {
        attendMeeting().start();
        completeLunch().start();
    }

    private static Thread attendMeeting(){
        var message = "Platform Thread [Attend Meeting]";
        return new Thread(() -> {
            logger.info(STR."{} | \{message}", Thread.currentThread());
        });
    }

    private static Thread completeLunch(){
        var message = "Platform Thread [Complete Lunch]";
        return new Thread(() -> {
            logger.info(STR."{} | \{message}", Thread.currentThread());
        });
    }

    // using builder pattern to create platform threads
    private static void attendMeeting1(){
        var message = "Platform Thread [Attend Meeting]";
        Thread.ofPlatform().start(() -> {
            logger.info(STR."{} | \{message}", Thread.currentThread());
        });
    }

    private static void completeLunch1(){
        var message = "Platform Thread [Complete Lunch]";
        Thread.ofPlatform().start(() -> {
            logger.info(STR."{} | \{message}", Thread.currentThread());
        });
    }
}

上面的代码用两种方式创建平台线程：

  1. 使用Thread的构造方法，传一个实现Runnable接口的lambda表达式进去。
  2. 使用Thread的ofPlatform()构建方法

再来看一下更复杂的虚拟线程：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.TimeUnit;

public class DailyRoutineWorkflow {
    static final Logger logger = LoggerFactory.getLogger(DailyRoutineWorkflow.class);

    static void log(String message) {
        logger.info(STR."{} | \{message}", Thread.currentThread());
    }


    private static void sleep(Long duration) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(duration);
    }

    private static Thread virtualThread(String name, Runnable runnable) {
        return Thread.ofVirtual().name(name).start(runnable);
    }

    static Thread attendMorningStatusMeeting() {
        return virtualThread(
                "Morning Status Meeting",
                () -> {
                    log("I'm going to attend morning status meeting");
                    try {
                        sleep(1000L);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    log("I'm done with morning status meeting");
                });
    }

    static Thread workOnTasksAssigned() {
        return virtualThread(
                "Work on the actual Tasks",
                () -> {
                    log("I'm starting my actual work on tasks");
                    try {
                        sleep(1000L);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    log("I'm done with actual work on tasks");
                });
    }

    static Thread attendEveningStatusMeeting() {
        return virtualThread(
                "Evening Status Meeting",
                () -> {
                    log("I'm going to attend evening status meeting");
                    try {
                        sleep(1000L);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    log("I'm done with evening status meeting");
                });
    }

    static void concurrentRoutineExecutor() throws InterruptedException {
        var morningMeeting = attendMorningStatusMeeting();
        var actualWork = workOnTasksAssigned();
        var eveningMeeting = attendEveningStatusMeeting();
        morningMeeting.join();
        actualWork.join();
        eveningMeeting.join();
    }
}

上面的代码展示了如何用工厂方法创建虚拟线程。除了工厂方法外，我们还可以使用为虚拟线程java.util.concurrent.ExecutorService定制的子类java.util.concurrent.ThreadPerTaskExecutor。可以像下面这样使用ExecutorService：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DailyRoutineWorkflowUsingExecutors {
    static final Logger logger = LoggerFactory.getLogger(DailyRoutineWorkflowUsingExecutors.class);

    static void log(String message) {
        logger.info(STR."{} | \{message}", Thread.currentThread());
    }


    private static void sleep(Long duration) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(duration);
    }

    public static void executeJobRoute() throws ExecutionException, InterruptedException {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            var morningMeeting = executor.submit(() -> {
                log("I'm going to attend morning status meeting");
                try {
                    sleep(1000L);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log("I'm done with morning status meeting");
            });

            var actualWork = executor.submit(() -> {
                log("I'm starting my actual work on tasks");
                try {
                    sleep(1000L);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log("I'm done with actual work on tasks");
            });

            var eveningMeeting = executor.submit(() -> {
                log("I'm going to attend evening status meeting");
                try {
                    sleep(1000L);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log("I'm done with evening status meeting");
            });

            morningMeeting.get();
            actualWork.get();
            eveningMeeting.get();
        }
    }
}

分析输出结果

如果运行上面代码，会得到类似下面的日志：
在这里插入图片描述
日志被“｜”分成了两部分。第一部分像这样VirtualThread[#26]/runnable@ForkJoinPool-1-worker-3。告诉我们VirtualThread[#26]这个虚拟线程运行在ForkJoinPool-1-worker-3这个平台线程上。

ThreadLocal和虚拟线程

在Java中，ThreadLocal是一种让每个线程保存不同对象的机制。每个线程访问ThreadLocal变量，都会线程各自对应的值。修改ThreadLocal变量，不会影响其它线程中的值。ThreadLocal被用于维持各自线程的状态，比如用户的Session、数据库连接。

但是，与虚拟线程一起使用时，ThreadLocal的行为有很大的改变。虚拟线程是由JVM管理的轻量级线程，会被大量调度，不像传统的平台线程，与操作系统线程一对一绑定。

由于 VirtualThreads 可以创建数百万个，因此创建和使用 ThreadLocal 会造成内存泄漏。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo {
    private static ThreadLocal<String> stringThreadLocal = new ThreadLocal<>();

    static final Logger logger = LoggerFactory.getLogger(DailyRoutineWorkflow.class);

    static void log(String message) {
        logger.info(STR."{} | \{message}", Thread.currentThread());
    }

    private static void sleep(Long duration) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(duration);
    }

    public static void virtualThreadContext() throws InterruptedException {
        var virtualThread1 = Thread.ofVirtual().name("thread-1").start(() -> {
            stringThreadLocal.set("thread-1");
            try {
                sleep(1000L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            log(STR."thread name is \{stringThreadLocal.get()}");
        });
        var virtualThread2 = Thread.ofVirtual().name("thread-2").start(() -> {
            stringThreadLocal.set("thread-2");
            try {
                sleep(1000L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            log(STR."thread name is \{stringThreadLocal.get()}");
        });
        virtualThread1.join();
        virtualThread2.join();
    }
}

结尾

本文介绍了Java的线程模型、虚拟线程、平台线程、ThreadLocal的问题。揭示了Java并发编程的发展现状。虚拟线程的出现改变了游戏规则。与平台线程相比，更轻量、更有效率。使Java可以使用最少的资源消耗，处理大量的并发任务。简化了编程模型，加强了程序的可扩展性。

然而，在这种新情况下使用 ThreadLocal 需要仔细考虑。在传统线程中，ThreadLocal 仍然是维护线程数据的强大工具。但在虚拟线程中，它的应用变得更加复杂，因此需要采用其他策略来管理状态和上下文。为开发人员构建响应式、可扩展和更高效的应用程序打开了新的大门。

标签
#java #开发语言
Java多线程基础：虚拟线程与平台线程解析
Kenard的博客
01-16 1528
虚拟线程成为一个颠覆性的变革者，提供了轻量级、高效的并发性，与平台线程资源密集型的特性形成鲜明对比。它们通过在最小资源开销下使大量并发任务成为可能，从而改变了Java处理多线程的方式，简化了编程模型并增强了应用程序的可扩展性。然而，在这个新背景下对ThreadLocal的使用的复杂性突显了需要谨慎考虑的必要性。虽然ThreadLocal在传统线程中保持特定于线程的数据方面仍然是一个强大的工具，但在虚拟线程中，它的应用变得更加复杂，需要替代策略来进行状态和上下文管理。
Java19 虚拟线程原理介绍及实现
Hello！
11-02 5599
本文介绍了 Java 线程模型、Java 虚拟线程的使用、原理和适用场景，并与流行的 Go 协程 进行了比较，也发现了两种实现方式的相似之处，希望对大家理解 Java 虚拟线程有所帮助。
Java 21中的虚拟线程与传统平台线程对比分析
最新发布
04-30 168
虚拟线程，也称为用户模式线程或协程，是Java 21中引入的一种新型线程模型。与传统的平台线程（由操作系统内核管理）不同，虚拟线程由Java虚拟机（JVM）直接管理，无需操作系统内核的介入。这种设计使得虚拟线程的创建、调度和销毁成本极低，能够支持数以百万计的并发线程。虚拟线程的主要用途在于简化高并发网络编程和I/O密集型任务的处理。通过虚拟线程，开发者可以轻松编写出处理大量并发连接的服务器应用，而无需担心线程资源耗尽的问题。
java虚拟机-java与线程
qq_46577594的博客
03-23 649
java与线程java与线程线程的实现线程实现的三种方式java线程调度 java与线程 并发不一定依赖于多线程，例如php的多进程并发。但是java里的并发，多数与线程有关。 线程的实现 我们知道，进程是资源分配的基本单位，线程是cpu调度的基本单位。线程既可以共享进程的资源（内存地址，文件i/o等），又可以单独调度。 主流操作系统都提供了线程实现，java语言则提供了在不同硬件和操作系统平台下线程操作的统一处理。 每个java.lang.Thread类的实例就代表一个线程，其中关键方法都被声明为nati
Java虚拟线程和普通线程的区别
xiongjikai的博客
02-14 1649
虚拟线程适合高并发、I/O 密集型任务，创建和管理更简单，资源消耗更低。平台线程适合 CPU 密集型任务，创建和管理更复杂，资源消耗更高。通过合理选择和使用虚拟线程和平台线程，可以显著提高应用程序的性能和可维护性。
JVM系列之java虚拟机与线程
a_ittle_pan的博客
08-08 568
“少年读书，如隙中窥月；中年读书，如庭中望月；老年读书，如台上玩月。皆以阅历之深浅，为所得之深浅耳” 参考书籍：“深入理解Java虚拟机”个人java知识分享项目——gitee地址个人java知识分享项目——github地址线程出现的场合一般都会有数据并发安全，而如何保证数据并发安全又是java程序员必备的一项技能，今天这篇文章我们就从java虚拟机的角度去了解线程的底层原理。let’s go!! 我们知道，线程是比进程更轻量级的调度执行单位，线程的引入，可以把一个进程的资源分配和执行调度分开，各个线程既
【Java 19虚拟线程深度解析】：平台线程 vs 虚拟线程性能对比，提升并发效率的终极选择？
ByteGlow的博客
10-31 816
深入解析Java 19虚拟线程与平台线程对比，揭示高并发场景下的性能差异与应用策略。通过实际测试展示虚拟线程在吞吐量、资源消耗方面的显著优势，助你优化系统并发模型。提升效率的关键选择，值得收藏。
Java虚拟线程 vs 平台线程内存对比：实测百万并发下的真实消耗
FuncWander的博客
01-03 779
实测揭示Java虚拟线程内存占用优势，对比平台线程在百万并发下的真实消耗。适用于高并发服务器应用，采用轻量级线程模型显著降低资源开销，提升吞吐量。性能优化必读，值得收藏
Java虚拟线程 vs 平台线程性能对比（百万级并发实测数据曝光）
FuncFun的博客
01-02 888
揭秘Java虚拟线程性能优势，通过百万级并发实测对比虚拟线程与平台线程。涵盖高并发场景下的内存占用、吞吐量及响应时间，展示Java虚拟线程在I/O密集型应用中的卓越表现。基于JDK21真实压测数据，助你掌握新一代线程模型优化方案。Java虚拟线程性能测试深度解析，值得收藏。
虚拟线程 vs 平台线程：Java 19中你必须知道的7个性能陷阱与优化技巧
AlgoChat的博客
10-31 428
掌握Java 19虚拟线程与平台线程对比，深入解析7大性能陷阱与优化策略。涵盖高并发场景适用性、资源消耗差异与响应效率提升技巧，助你合理选择线程模型。性能优化关键方法一文掌握，值得收藏。
从阻塞到虚拟线程，Java响应式重构必问的8个关键问题：你答对几个？
FuncInk的博客
04-09 324
帮你规避Java项目Loom与响应式编程转型中的典型陷阱，提供可落地的转型指南与避坑指南。覆盖虚拟线程适配、阻塞调用迁移、Reactor/Project Reactor集成等8大关键问题，适用于高并发微服务场景，显著提升吞吐与可观测性。值得收藏
Java SE 22 是 Oracle 于 2024 年 3 月 19 日正式发布的标准版 Java 平台（JDK 22）
[Blog][Domain] programb.blog.csdn.net
03-29 355
Java SE 22 是 Oracle 于 2024 年 3 月 19 日正式发布的标准版 Java 平台（JDK 22），是 Java 的最新长期支持（LTS）版本之前的**非LTS版本**（注意：Java SE 22 是**特性发布版，非LTS**；当前 LTS 版本为 Java 21，下一个 LTS 将是 Java 25，预计 2025 年 9 月发布）。JDK 22 引入了多项重要新特性与改进，主要包括：
半编译语言Java、C#、Kotlin、Scala和Groovy性能终极对决
I am “技术科普侠”！
04-10 382
2025年半编译语言技术分析显示，主流字节码语言在性能与生态方面各具优势。Java保持企业级首选，ZGC暂停<10ms；C#以.NET 10领跑性能，NativeAOT启动仅120ms；Kotlin协程实现高效并发，内存占用比线程低90%；Scala仍是大数据处理首选；Groovy则擅长脚本开发。性能方面，C#在计算密集型任务达C++的90%，Java为85%。并发模型中，C# async/await处理125万QPS，Kotlin协程10万并发仅需150MB内存。选型需综合性能需求（C#最优）、开发
2026最新JAVA基础面试题
m0_64006292的博客
03-11 373
摘要：本文系统介绍了Java的核心特性、数据类型、面向对象编程、设计模式等关键知识点。主要内容包括：1. Java特点解析：跨平台性（JVM机制）、面向对象、安全性、健壮性；2. 数据类型详解：基本类型与包装类区别、类型转换问题、BigDecimal精度处理；3. OOP核心：封装/继承/多态、抽象类与接口区别、内部类分类；4. 高级特性：反射原理、注解机制、异常处理、泛型应用；5. 新特性对比：Java8的Lambda/Stream与Java21的虚拟线程等；6. 设计模式实践：单例模式实现、代理/适配器
JAVA虚线程简介-译
qrycsa的博客
06-14 134
本文加入了部分个人理解，省去了部分和主旨关系较弱的段落，可作为虚线程的概览，有时间推荐阅读非常优秀的原文。原文地址链接：Virtual Threads: New Foundations for High-Scale Java Applications。 术语说明 virtual thread：虚线程。 thread-per-request：每个线程处理一个请求。 runtime：运行时。 s...
虚拟线程详解
正在努力~
02-17 2110
一文带你快速了解虚拟线程
Spring Boot 虚拟线程 vs WebFlux：谁更胜一筹？
程序猿DD
06-19 1585
Spring Boot 虚拟线程和 WebFlux 都是构建可扩展应用的强大工具，但各自适用于不同的需求场景。虚拟线程凭借其简洁性、兼容性和以最小改动实现高并发处理的能力，成为大多数项目的首选方案。它为传统 Spring MVC 应用带来了革命性改变，在保持简单性的同时提供了接近响应式的性能表现。而WebFlux在需要超低延迟或流处理的特殊场景中仍然具有不可替代的价值，其响应式模型在这些领域表现卓越。对于 2025 年的大多数开发者而言，虚拟线程在性能和开发效率之间找到了最佳平衡点，使其成为默认选择。
深耕Java：从零基础到行业前沿，解锁后端开发的长期价值
从零开始，掌握网络安全。提供全面的网络安全教程、攻防演练技巧和行业动态。
03-17 558
Java作为编程领域的"常青树"，凭借跨平台、面向对象、完善生态和高稳定性四大核心优势，长期占据行业核心地位。本文系统解析Java的价值与学习路径：首先阐述Java在安卓开发、企业系统等领域的广泛应用；其次详细拆解环境搭建、编辑器选择等零基础入门指南；最后从核心技术、行业前景等维度提供科学学习路线。无论是编程新手选择入门语言，还是开发者规划职业路径，Java都是兼具友好性与发展潜力的优质选择，掌握Java技术栈将有效提升在技术浪潮中的竞争力。
java 21虚拟线程vs传统线程 原理分析以及具体测试例子去分析性能提升
qq_44716086的博客
06-17 1229
摘要：Java虚拟线程深度解析 本文系统介绍了Java 21引入的虚拟线程技术。虚拟线程是JVM用户态实现的轻量级线程，相比传统OS线程具有显著优势：内存占用从MB级降至KB级，支持百万级并发；在I/O阻塞时能自动挂起释放资源，通过N:M映射机制实现高效调度。文章通过代码示例展示了虚拟线程与传统线程的差异，并设计微服务测试案例对比两者性能。虚拟线程本质是Java对协程的实现，其核心原理在于任务挂载/卸载机制和Continuation状态保存。适用于高并发I/O场景，但需注意CPU密集型任务仍需传统线程。配置
【jdk19虚拟线程 VS 普通线程】
weixin_44585177的博客
10-11 1404
主要介绍下jdk19的新特性虚拟线程，真是性能优化的又一大利器啊！如果小伙伴们项目里面jdk有紧跟潮流，在合适的业务场景不妨试试吧~
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值