进程、线程、协程、虚拟线程，傻傻分不清楚

苏三说技术2025-09-25 10:30

前言

最近虚拟线程火了。

但有些小伙伴对进程、线程、协程、虚拟线程之间的区别和联系还是没有搞清楚。

今天这篇文章就跟大家一起聊聊，希望对你会有所帮助。

一、进程与线程

有些小伙伴在工作中可能经常听到"进程"和"线程"这两个词，但未必真正理解它们之间的本质区别。

让我用一个简单的比喻来解释：

想象一家大工厂（操作系统）：

  • 进程就像工厂中的一个独立车间，每个车间有自己独立的空间、原料和工具。
  • 线程就像车间中的工人，共享车间的资源，协同完成生产任务。

进程：独立的执行环境

进程是操作系统进行资源分配和调度的基本单位。

每个进程都有自己独立的地址空间、数据栈、代码段和其他系统资源。

java 复制代码 
// Java中创建进程的示例
public class ProcessExample {
    public static void main(String[] args) throws IOException {
        // 启动一个新的进程（比如打开计算器）
        ProcessBuilder processBuilder = new ProcessBuilder("calc.exe");
        Process process = processBuilder.start();
        
        System.out.println("进程ID: " + process.pid());
        System.out.println("是否存活: " + process.isAlive());
        
        // 等待进程结束
        try {
            int exitCode = process.waitFor();
            System.out.println("进程退出码: " + exitCode);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

进程的特点：

  1. 独立性：每个进程有独立的地址空间，互不干扰
  2. 安全性：一个进程崩溃不会影响其他进程
  3. 开销大：创建和销毁进程需要较大的系统开销
  4. 通信复杂：进程间通信（IPC）需要特殊的机制

线程：轻量级的执行单元

线程是进程内的执行单元，是CPU调度和执行的基本单位。

一个进程可以包含多个线程，这些线程共享进程的资源。

java 复制代码 
// Java中创建线程的两种方式
public class ThreadExample {
    public static void main(String[] args) {
        // 方式1：继承Thread类
        Thread thread1 = new MyThread();
        thread1.start();
        
        // 方式2：实现Runnable接口
        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
        
        // 方式3：使用Lambda表达式
        Thread thread3 = new Thread(() -> {
            System.out.println("Lambda线程执行: " + Thread.currentThread().getName());
        });
        thread3.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread执行: " + Thread.currentThread().getName());
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable执行: " + Thread.currentThread().getName());
    }
}

线程的特点：

  1. 共享资源：同一进程内的线程共享内存空间和系统资源
  2. 轻量级：创建和销毁线程的开销比进程小
  3. 通信简单：线程间可以直接读写共享数据
  4. 安全性问题：需要处理线程同步和资源共享问题

二、线程的深入剖析

要真正理解线程，我们需要深入操作系统层面。

现代操作系统通常采用三种线程模型：

1. 用户级线程（ULT）

用户级线程完全在用户空间实现，操作系统不知道它们的存在。线程的创建、调度、同步等都由用户级的线程库完成。

优点：

  • 线程切换不需要陷入内核态，开销小
  • 调度算法可以由应用程序自定义
  • 不依赖于操作系统支持

缺点：

  • 一个线程阻塞会导致整个进程阻塞
  • 无法利用多核CPU的优势

2. 内核级线程（KLT）

内核级线程由操作系统内核直接支持和管理。每个内核线程对应一个内核级的调度实体。

优点：

  • 一个线程阻塞不会影响其他线程
  • 能够利用多核CPU并行执行

缺点：

  • 线程切换需要陷入内核态，开销较大
  • 创建线程需要系统调用

3. 混合模型

现代操作系统通常采用混合模型，将用户级线程映射到内核级线程上。

Java线程就是这种模型的具体实现。

java 复制代码 
// Java线程与操作系统线程的对应关系
public class ThreadInfoExample {
    public static void main(String[] args) {
        // 创建多个线程
        for (int i = 0; i < 5; i++) {
            int threadId = i;
            new Thread(() -> {
                System.out.println("Java线程: " + Thread.currentThread().getName() +
                                 ", 操作系统线程ID: " + getThreadId());
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
    
    // 获取操作系统线程ID（Java 10+）
    private static long getThreadId() {
        return Thread.currentThread().threadId();
    }
}

三、协程

有些小伙伴可能听说过协程（Coroutine），尤其是在Go语言中非常流行。

那么协程和线程有什么区别呢？

协程的本质

协程是一种比线程更加轻量级的执行单元，它由程序员在用户空间控制调度，而不是由操作系统内核调度。

java 复制代码 
// Java中可以使用第三方库实现协程（如Quasar）
// 以下是伪代码示例，展示协程的概念
public class CoroutineExample {
    public static void main(String[] args) {
        // 创建协程
        Coroutine coroutine1 = new Coroutine(() -> {
            System.out.println("协程1开始");
            Coroutine.yield(); // 主动让出执行权
            System.out.println("协程1继续");
        });
        
        Coroutine coroutine2 = new Coroutine(() -> {
            System.out.println("协程2开始");
            Coroutine.yield(); // 主动让出执行权
            System.out.println("协程2继续");
        });
        
        // 手动调度协程
        coroutine1.run();
        coroutine2.run();
        coroutine1.run();
        coroutine2.run();
    }
}

协程的特点：

  1. 极轻量级：一个程序可以轻松创建数十万个协程
  2. 协作式调度：由程序员控制调度时机
  3. 低成本切换：切换不需要陷入内核态
  4. 同步编程风格：可以用同步的方式编写异步代码

协程 vs 线程

为了更清晰地理解协程和线程的区别。

我们先看看执行单元的对比图：

再看看创建数量的对比图：

四、虚拟线程

Java 19引入了虚拟线程（Virtual Threads），这是Java并发模型的一次重大革新。

虚拟线程旨在解决传统平台线程的局限性。

为什么需要虚拟线程？

有些小伙伴在工作中可能遇到过下面这些的问题。

为了处理大量并发请求，我们创建了大量线程，但很快遇到了瓶颈：

  1. 线程数量限制：操作系统线程数有限制（通常几千个）
  2. 内存开销大：每个线程都需要分配栈内存（默认1MB）
  3. 上下文切换开销：线程切换需要内核参与，开销较大

虚拟线程的实现原理

虚拟线程是JDK实现的轻量级线程，它们不是由操作系统直接调度，而是由JDK调度到平台线程（操作系统线程）上执行。

java 复制代码 
// Java 19+ 虚拟线程使用示例
public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建虚拟线程
        Thread virtualThread = Thread.ofVirtual().start(() -> {
            System.out.println("虚拟线程执行: " + Thread.currentThread());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        // 等待虚拟线程结束
        virtualThread.join();
        
        // 使用虚拟线程处理大量任务
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10_000; i++) {
                int taskId = i;
                executor.submit(() -> {
                    System.out.println("任务 " + taskId + " 在线程: " + Thread.currentThread());
                    Thread.sleep(1000);
                    return taskId;
                });
            }
        }
    }
}

虚拟线程的优势

  1. 轻量级：可以创建数百万个虚拟线程而不会耗尽资源
  2. 低成本阻塞：虚拟线程阻塞时不会阻塞平台线程
  3. 简化并发编程：可以用同步的代码风格编写高并发程序
  4. 兼容现有代码：虚拟线程是Thread的实现，兼容现有API

五、虚拟线程如何工作？

为了真正理解虚拟线程，我们需要深入其工作原理。

虚拟线程的实现基于一个关键概念：continuation。

Continuation的概念

Continuation表示一个可暂停和恢复的执行上下文。当虚拟线程执行阻塞操作时，JDK会挂起当前的continuation，并释放平台线程去执行其他任务。

java 复制代码 
// 伪代码：展示continuation的概念
public class ContinuationExample {
    public static void main(String[] args) {
        ContinuationScope scope = new ContinuationScope("example");
        
        Continuation continuation = new Continuation(scope, () -> {
            System.out.println("步骤1");
            Continuation.yield(scope); // 暂停执行
            
            System.out.println("步骤2");
            Continuation.yield(scope); // 暂停执行
            
            System.out.println("步骤3");
        });
        
        // 分步执行
        while (!continuation.isDone()) {
            System.out.println("开始执行步骤...");
            continuation.run();
            System.out.println("步骤执行暂停");
        }
    }
}

虚拟线程的调度模型

虚拟线程使用ForkJoinPool作为调度器，将虚拟线程调度到平台线程上执行。

当一个虚拟线程执行阻塞操作时，调度器会自动将其挂起，并调度其他虚拟线程到平台线程上执行。

这种调度模型使得少量平台线程可以高效地执行大量虚拟线程，极大地提高了系统的并发能力。

六、不同场景下的选择

有些小伙伴可能会问：既然虚拟线程这么强大，是不是应该全部使用虚拟线程呢？其实不然，不同的场景适合不同的并发模型。

1. CPU密集型任务

对于CPU密集型任务（如计算、数据处理），传统线程可能更合适：

java 复制代码 
// CPU密集型任务示例
public class CpuIntensiveTask {
    public static void main(String[] args) {
        int processors = Runtime.getRuntime().availableProcessors();
        ExecutorService executor = Executors.newFixedThreadPool(processors);
        
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                // 复杂的计算任务
                compute();
            });
        }
        
        executor.shutdown();
    }
    
    private static void compute() {
        // 模拟CPU密集型计算
        long result = 0;
        for (long i = 0; i < 100000000L; i++) {
            result += i * i;
        }
        System.out.println("计算结果: " + result);
    }
}

2. IO密集型任务

对于IO密集型任务（如网络请求、数据库操作），虚拟线程有明显的优势：

java 复制代码 
// IO密集型任务示例 - 使用虚拟线程
public class IoIntensiveTask {
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10_000; i++) {
                executor.submit(() -> {
                    // 模拟IO操作
                    String data = httpGet("https://api.example.com/data");
                    processData(data);
                    return null;
                });
            }
        }
    }
    
    private static String httpGet(String url) {
        // 模拟HTTP请求
        try {
            Thread.sleep(100); // 模拟网络延迟
            return "response data";
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    
    private static void processData(String data) {
        // 处理数据
        System.out.println("处理数据: " + data);
    }
}

3. 混合型任务

对于既有CPU计算又有IO操作的任务，可以根据具体情况选择：

java 复制代码 
// 混合型任务示例
public class MixedTask {
    public static void main(String[] args) {
        // 对于IO部分使用虚拟线程
        try (var ioExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = new ArrayList<>();
            
            for (int i = 0; i < 1000; i++) {
                futures.add(ioExecutor.submit(() -> {
                    // IO操作
                    return fetchData();
                }));
            }
            
            // 对于CPU密集型部分使用固定线程池
            int processors = Runtime.getRuntime().availableProcessors();
            ExecutorService cpuExecutor = Executors.newFixedThreadPool(processors);
            
            for (Future<String> future : futures) {
                cpuExecutor.submit(() -> {
                    try {
                        String data = future.get();
                        // CPU密集型处理
                        processDataIntensively(data);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
            
            cpuExecutor.shutdown();
        }
    }
}

七、性能对比

为了更直观地展示不同并发模型的性能差异，我们来看一个简单的性能测试：

java 复制代码 
// 性能对比测试
public class PerformanceComparison {
    private static final int TASK_COUNT = 10000;
    private static final int IO_DELAY_MS = 100;
    
    public static void main(String[] args) throws InterruptedException {
        // 测试平台线程
        long startTime = System.currentTimeMillis();
        testPlatformThreads();
        long platformTime = System.currentTimeMillis() - startTime;
        
        // 测试虚拟线程
        startTime = System.currentTimeMillis();
        testVirtualThreads();
        long virtualTime = System.currentTimeMillis() - startTime;
        
        System.out.println("平台线程耗时: " + platformTime + "ms");
        System.out.println("虚拟线程耗时: " + virtualTime + "ms");
        System.out.println("性能提升: " + (double) platformTime / virtualTime + "倍");
    }
    
    private static void testPlatformThreads() throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(200);
        CountDownLatch latch = new CountDownLatch(TASK_COUNT);
        
        for (int i = 0; i < TASK_COUNT; i++) {
            executor.submit(() -> {
                try {
                    Thread.sleep(IO_DELAY_MS); // 模拟IO操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });
        }
        
        latch.await();
        executor.shutdown();
    }
    
    private static void testVirtualThreads() throws InterruptedException {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            CountDownLatch latch = new CountDownLatch(TASK_COUNT);
            
            for (int i = 0; i < TASK_COUNT; i++) {
                executor.submit(() -> {
                    try {
                        Thread.sleep(IO_DELAY_MS); // 模拟IO操作
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();
                    }
                });
            }
            
            latch.await();
        }
    }
}

测试结果分析：

  • 平台线程池（200线程）：处理10000个任务约50秒
  • 虚拟线程：处理10000个任务约1秒
  • 性能提升：约50倍

这个测试清楚地展示了虚拟线程在IO密集型场景下的巨大优势。

总结

经过上面的详细讲解，现在我们来总结一下各种并发模型的适用场景和最佳实践：

1. 进程 vs 线程 vs 协程 vs 虚拟线程

特性 进程 线程 协程 虚拟线程
隔离性 高 低 低 低
创建开销 大 中 小 极小
切换开销 大 中 小 小
内存占用 大 中 小 小
并发数量 几十个 几千个 几十万 百万级
适用场景 独立应用 通用并发 特定语言 IO密集型

2. 选择指南

  • 需要完全隔离：选择进程（如微服务架构）
  • CPU密集型任务：选择平台线程池（线程数≈CPU核心数）
  • IO密集型任务：选择虚拟线程（Java 19+）
  • 极高并发需求：考虑协程（如Go语言）或虚拟线程
  • 现有系统迁移：逐步引入虚拟线程，保持兼容性

3. 最佳实践

有些小伙伴在工作中使用并发编程时，可以参考以下最佳实践：

  1. 避免过度使用线程：不要创建过多平台线程
  2. 合理使用线程池：根据任务类型选择合适的线程池
  3. 尝试虚拟线程：在IO密集型场景中尝试使用虚拟线程
  4. 监控线程状态：使用监控工具跟踪线程使用情况
  5. 理解业务特性：根据业务需求选择合适的并发模型

未来展望

虚拟线程是Java并发编程的一次重大飞跃，但它们并不是终点。

随着硬件技术的发展和应用场景的变化，并发模型还会继续演进：

  1. 更好的工具支持：调试、监控工具需要适应虚拟线程
  2. 更优的调度算法：针对不同场景的智能调度
  3. 新的编程模型：响应式编程、actor模型等与虚拟线程的结合
  4. 硬件协同优化：与新一代硬件（如DPU）的协同优化

记住：没有最好的并发模型，只有最适合的并发模型。

作为开发者，我们需要根据具体场景做出明智的选择。

最后说一句(求关注，别白嫖我)

如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下我的同名公众号：苏三说技术，您的支持是我坚持写作最大的动力。

求一键三连：点赞、转发、在看。

关注公众号：【苏三说技术】，在公众号中回复：进大厂，可以免费获取我最近整理的10万字的面试宝典，好多小伙伴靠这个宝典拿到了多家大厂的offer。

更多项目实战在我的技术网站：http://www.susan.net.cn/project

热门推荐
01UV 工具安装与国内镜像源配置指南02GitHub 镜像站点03Spec-Kit 使用指南04UV安装并设置国内源0546个Nano-banana 精选提示词，持续更新中062025年华为杯研赛数学建模竞赛C题完整参考论文 （含模型、MATLAB和Python代码）07保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）08KGG转MP3工具|非KGM文件|解密音频09Linux下V2Ray安装配置指南10解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题