【后端】【JAVA】协程：从虚拟线程到协程编程的全面解析

小毅&Nora2025-12-03 11:27

📖目录

  • 前言：为什么我们需要协程？
  • [1. 进程、线程、协程、纤程与Virtual Threads的关系](#1. 进程、线程、协程、纤程与Virtual Threads的关系)
  • [2. 为什么需要协程？线程还不够用吗？](#2. 为什么需要协程？线程还不够用吗？)
  • [3. Java协程的实现：Virtual Threads](#3. Java协程的实现：Virtual Threads)
    • [3.1 创建Virtual Threads](#3.1 创建Virtual Threads)
    • [3.2 协程与线程的性能对比](#3.2 协程与线程的性能对比)
  • [4. 协程的使用场景与注意事项](#4. 协程的使用场景与注意事项)
    • [4.1 适用场景](#4.1 适用场景)
    • [4.2 不适用场景](#4.2 不适用场景)
    • [4.3 注意事项](#4.3 注意事项)
  • [5. Java 21与Java 25中的协程发展](#5. Java 21与Java 25中的协程发展)
    • [5.1 Java 21：虚拟线程的诞生](#5.1 Java 21：虚拟线程的诞生)
    • [5.2 Java 25：协程的进一步完善](#5.2 Java 25：协程的进一步完善)
    • [5.3 未来发展方向](#5.3 未来发展方向)
  • [6. 一个完整的协程示例](#6. 一个完整的协程示例)
  • [7. 结论：协程是Java并发编程的未来](#7. 结论：协程是Java并发编程的未来)

前言：为什么我们需要协程？

在Java并发编程的世界里，线程一直是处理并发的核心机制。然而，随着互联网应用规模的不断扩大，传统线程模型的局限性逐渐暴露：高并发场景下线程创建开销大、内存占用高、系统资源消耗大，导致应用吞吐量受限。这正是协程（Coroutine）被引入Java生态的原因------它提供了一种更高效、更轻量级的并发编程模型。

在Java 21中，OpenJDK通过Project Loom引入了虚拟线程（Virtual Threads），这是协程在Java中的实现方式。虚拟线程不是传统意义上的线程，而是由JVM管理的轻量级线程，它解决了传统线程模型的痛点，让高并发应用开发变得简单而高效。

1. 进程、线程、协程、纤程与Virtual Threads的关系

让我们先从基础概念入手，理清这些并发模型之间的关系：

概念 调度方式 切换成本 内存占用 并发数量 适用场景
进程 操作系统调度 毫秒级 MB级 有限 独立应用程序
线程 操作系统调度 微秒级 MB级 数千-数万 CPU密集型任务
协程 协作式调度 纳秒级 KB级 百万级 I/O密集型任务
纤程 协作式调度 纳秒级 KB级 百万级 协程底层实现
Virtual Threads JVM调度 纳秒级 KB级 百万级 I/O密集型任务

关键区别：

  1. 进程 vs 线程：

    • 进程是操作系统分配资源的基本单位，拥有独立的内存空间
    • 线程是进程内的执行单元，共享进程的内存空间和资源

  2. 线程 vs 协程：

    • 线程由操作系统调度，切换需要内核态切换
    • 协程由用户代码调度，切换在用户态完成，无需内核介入

  3. 协程 vs 纤程：

    • 纤程是协程的底层实现机制，提供了一种轻量级的执行上下文切换
    • 协程是纤程的高级抽象，提供了更易用的API

  4. Virtual Threads vs 传统线程：

    • Virtual Threads是JVM管理的轻量级线程，由JVM调度
    • 传统线程是操作系统管理的线程，由操作系统调度

2. 为什么需要协程？线程还不够用吗？

传统线程模型存在几个关键问题：

  1. 创建成本高：创建线程需要分配系统资源，通常需要1MB左右的栈空间
  2. 并发数量受限：一般系统只能支持数千到数万个线程
  3. 阻塞问题：线程阻塞会占用系统资源，导致CPU利用率低下

以一个简单的例子说明：一个Web服务器处理10万个并发请求。如果使用传统线程模型，每个请求都需要一个线程，那么需要创建10万个线程。假设每个线程占用1MB内存，总共需要100GB内存，这在大多数服务器上是不可行的。

而使用协程（Virtual Threads），可以轻松处理百万级并发，因为每个协程只需要KB级别的内存，且创建成本极低。

3. Java协程的实现：Virtual Threads

Java 21（JEP 425）正式引入了虚拟线程（Virtual Threads），这是Project Loom项目的核心成果。Java 25继续完善了相关特性。

3.1 创建Virtual Threads

java 复制代码 
// 创建虚拟线程
Thread thread = Thread.ofVirtual().name("my-virtual-thread").start(() -> {
    System.out.println("虚拟线程执行中，当前线程: " + Thread.currentThread().getName());
    try {
        Thread.sleep(1000); // 模拟I/O操作
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

// 创建虚拟线程池
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> {
    System.out.println("虚拟线程池中的任务执行中，当前线程: " + Thread.currentThread().getName());
});

3.2 协程与线程的性能对比

java 复制代码 
public class CoroutineBenchmark {
    public static void main(String[] args) throws InterruptedException {
        // 测试创建100万个"线程"
        testThreadCreation();
    }

    public static void testThreadCreation() throws InterruptedException {
        long start = System.currentTimeMillis();
        
        // 使用虚拟线程
        List<Thread> threads = IntStream.range(0, 1_000_000)
                .mapToObj(i -> Thread.ofVirtual()
                        .name("virtual-thread-" + i)
                        .start(() -> {
                            try {
                                Thread.sleep(100); // 模拟I/O操作
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                            }
                        }))
                .toList();
        
        // 等待所有线程完成
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        System.out.println("虚拟线程创建和执行完成，耗时: " + (System.currentTimeMillis() - start) + "ms");
    }
}

典型结果：

  • 虚拟线程：创建100万个线程约2秒，内存占用约1GB
  • 传统线程：可能OOM或耗时数分钟

4. 协程的使用场景与注意事项

4.1 适用场景

  • 高并发I/O应用：如Web服务器、API网关、数据库连接池
  • 异步编程：简化回调地狱，提高代码可读性
  • 游戏开发：处理大量并发的游戏逻辑
  • 数据处理：流水线式数据处理，如日志分析、数据转换

4.2 不适用场景

  • CPU密集型任务：如图像处理、科学计算
  • 长时间计算：协程不适合长时间运行的计算任务

4.3 注意事项

  • 避免阻塞：在协程中执行CPU密集型操作会阻塞其他协程
  • 异常处理：协程中的未捕获异常可能导致程序终止
  • 线程局部变量：虚拟线程可能在不同载体线程上运行，需注意ThreadLocal的使用

5. Java 21与Java 25中的协程发展

5.1 Java 21：虚拟线程的诞生

  • JEP 425：引入虚拟线程，作为Project Loom的初步实现
  • API变化 ：Thread.ofVirtual()、Executors.newVirtualThreadPerTaskExecutor()
  • 性能提升：在I/O密集型应用中，吞吐量可提升5-10倍

5.2 Java 25：协程的进一步完善

  • JEP 448：稳定了Virtual Threads API
  • JEP 450：改进了协程的性能和内存管理
  • StableValues：更严谨的不可变性支持
  • Vector API：为高性能计算提供更强大的API

5.3 未来发展方向

  • 协程作为语言原生特性：Java 25及以后版本可能将协程作为语言特性
  • 生态支持：数据库驱动、网络库等需要适配协程模型
  • 与Kotlin协程的整合：Java和Kotlin的协程模型可能进一步统一

6. 一个完整的协程示例

下面是一个包含所有协程特性的完整示例，展示了如何在Java中使用协程：

java 复制代码 
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class CoroutineExample {
    
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建虚拟线程
        createVirtualThreads();
        
        // 2. 使用虚拟线程池
        useVirtualThreadExecutor();
        
        // 3. 协程与线程的对比
        compareCoroutineWithThreads();
        
        // 4. 协程的异常处理
        handleCoroutineExceptions();
        
        // 5. 协程与线程局部变量
        handleThreadLocal();
    }
    
    private static void createVirtualThreads() {
        System.out.println("\n===== 创建虚拟线程 =====");
        List<Thread> threads = IntStream.range(0, 5)
                .mapToObj(i -> Thread.ofVirtual()
                        .name("virtual-thread-" + i)
                        .start(() -> {
                            System.out.println("虚拟线程 " + Thread.currentThread().getName() + 
                                    " 正在执行，线程ID: " + Thread.currentThread().getId());
                            try {
                                Thread.sleep(500);
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                            }
                        }))
                .collect(Collectors.toList());
        
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
    
    private static void useVirtualThreadExecutor() {
        System.out.println("\n===== 使用虚拟线程池 =====");
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        List<Future<String>> futures = IntStream.range(0, 5)
                .mapToObj(i -> executor.submit(() -> {
                    System.out.println("虚拟线程池任务 " + i + " 执行中，当前线程: " + Thread.currentThread().getName());
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "任务 " + i + " 完成";
                }))
                .toList();
        
        futures.forEach(future -> {
            try {
                System.out.println(future.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        
        executor.shutdown();
    }
    
    private static void compareCoroutineWithThreads() {
        System.out.println("\n===== 协程与传统线程性能对比 =====");
        System.out.println("测试创建10万个线程...");
        
        // 虚拟线程测试
        long start = System.currentTimeMillis();
        List<Thread> virtualThreads = IntStream.range(0, 100_000)
                .mapToObj(i -> Thread.ofVirtual()
                        .start(() -> {
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                            }
                        }))
                .toList();
        
        virtualThreads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        System.out.println("虚拟线程创建完成，耗时: " + (System.currentTimeMillis() - start) + "ms");
        
        // 传统线程测试
        start = System.currentTimeMillis();
        List<Thread> platformThreads = IntStream.range(0, 100_000)
                .mapToObj(i -> Thread.ofPlatform()
                        .start(() -> {
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                            }
                        }))
                .toList();
        
        platformThreads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        System.out.println("传统线程创建完成，耗时: " + (System.currentTimeMillis() - start) + "ms");
    }
    
    private static void handleCoroutineExceptions() {
        System.out.println("\n===== 协程异常处理 =====");
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        
        executor.submit(() -> {
            System.out.println("协程中抛出异常");
            throw new RuntimeException("测试异常");
        });
        
        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("协程异常已处理，程序继续执行");
    }
    
    private static void handleThreadLocal() {
        System.out.println("\n===== 协程与线程局部变量 =====");
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        threadLocal.set("主线程值");
        
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        executor.submit(() -> {
            System.out.println("协程1 - 线程局部变量: " + threadLocal.get());
            threadLocal.set("协程1值");
            System.out.println("协程1 - 设置后: " + threadLocal.get());
        });
        
        executor.submit(() -> {
            System.out.println("协程2 - 线程局部变量: " + threadLocal.get());
            threadLocal.set("协程2值");
            System.out.println("协程2 - 设置后: " + threadLocal.get());
        });
        
        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("主线程 - 线程局部变量: " + threadLocal.get());
    }
}

执行结果：

复制代码 
===== 创建虚拟线程 =====
虚拟线程 virtual-thread-3 正在执行，线程ID: 42
虚拟线程 virtual-thread-0 正在执行，线程ID: 37
虚拟线程 virtual-thread-4 正在执行，线程ID: 43
虚拟线程 virtual-thread-2 正在执行，线程ID: 41
虚拟线程 virtual-thread-1 正在执行，线程ID: 39

===== 使用虚拟线程池 =====
虚拟线程池任务 4 执行中，当前线程: 
虚拟线程池任务 1 执行中，当前线程: 
虚拟线程池任务 3 执行中，当前线程: 
虚拟线程池任务 0 执行中，当前线程: 
虚拟线程池任务 2 执行中，当前线程: 
任务 0 完成
任务 1 完成
任务 2 完成
任务 3 完成
任务 4 完成

===== 协程与传统线程性能对比 =====
测试创建10万个线程...
虚拟线程创建完成，耗时: 255ms
传统线程创建完成，耗时: 32993ms

===== 协程异常处理 =====
协程中抛出异常
协程异常已处理，程序继续执行

===== 协程与线程局部变量 =====
协程1 - 线程局部变量: null
协程1 - 设置后: 协程1值
协程2 - 线程局部变量: null
协程2 - 设置后: 协程2值
主线程 - 线程局部变量: 主线程值

7. 结论：协程是Java并发编程的未来

协程（通过Virtual Threads实现）是Java并发编程的重要里程碑。它解决了传统线程模型的痛点，为高并发I/O应用提供了更高效的解决方案。

为什么选择协程：

  1. 简单性：保留了传统Thread API，学习成本低
  2. 性能：可大幅提升系统吞吐量
  3. 可维护性：简化了异步编程，减少回调地狱
  4. 生态支持：随着Java 21+的普及，越来越多的框架和库开始支持协程

使用建议：

  • 对于新项目，建议在Java 21+上尝试虚拟线程
  • 对于现有系统，可逐步将合适的组件迁移到协程模型
  • 不要将协程用于CPU密集型任务
  • 注意协程中的异常处理和线程局部变量

随着Java生态的不断完善，协程有望成为Java并发编程的主流选择。正如Java 21引入的虚拟线程，它不是要取代传统线程，而是为不同场景提供更合适的并发模型。

未来展望：

  • Java 25及以后版本将进一步完善协程相关特性
  • 协程将与Kotlin协程等其他语言的协程模型更好地整合
  • 更多框架和库将原生支持协程，减少迁移成本

正如JDK 21的官方文档所说："虚拟线程是Java并发编程的未来。"让我们拥抱这一变化，用更简单、更高效的方式编写并发代码。

本文为原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文链接及本声明。

关键词：#Java协程 #虚拟线程 #并发编程 #Java21 #Java25 #VirtualThreads

相关推荐
free-elcmacom39 分钟前
Python信号分析项目：高速数字系统的眼图破案记
开发语言·python
Tao____39 分钟前
国产开源物联网基础平台
java·物联网·mqtt·开源·设备对接
f***a34641 分钟前
SpringBoot 如何调用 WebService 接口
java·spring boot·后端
A charmer43 分钟前
内存泄漏、死锁：定位排查工具+解决方案（C/C++ 实战指南）
c语言·开发语言·c++
断剑zou天涯43 分钟前
【算法笔记】KMP算法
java·笔记·算法
没事多睡觉66644 分钟前
JavaScript 中 this 指向教程
开发语言·前端·javascript
wjs20241 小时前
HTML 基础
开发语言
pilaf19901 小时前
Rust练习题
开发语言·后端·rust
asdfg12589631 小时前
replace(/,/g, ‘‘)；/\B(?=(\d{3})+(?!\d))/；千分位分隔
开发语言·前端·javascript
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04BongoCat - 跨平台键盘猫动画工具05本地部署阿里最新开源的Z-Image06Linux下V2Ray安装配置指南07【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）08Meta第三代“分割一切”模型——SAM 3本地部署教程：首支持文本提示分割，400万概念、30毫秒响应，检测分割追踪一网打尽09【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连10Labelme从安装到标注：零基础完整指南