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

文章 2小时前 cnblogshot

0 0 0

前言

最近虚拟线程火了。

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

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

一、进程与线程

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

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

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

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

进程：独立的执行环境

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

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

// 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();
        }
    }
}

进程的特点：

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

线程：轻量级的执行单元

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

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

// 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. 用户级线程（ULT）

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

优点：

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

缺点：

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

2. 内核级线程（KLT）

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

优点：

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

缺点：

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

3. 混合模型

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

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中可以使用第三方库实现协程（如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();
    }
}

协程的特点：

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

协程 vs 线程

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

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

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

四、虚拟线程

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

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

为什么需要虚拟线程？

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

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

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

虚拟线程的实现原理

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

// 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;
                });
            }
        }
    }
}

虚拟线程的优势

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

五、虚拟线程如何工作？

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

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

Continuation的概念

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

// 伪代码：展示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密集型任务（如计算、数据处理），传统线程可能更合适：

// 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密集型任务（如网络请求、数据库操作），虚拟线程有明显的优势：

// 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操作的任务，可以根据具体情况选择：

// 混合型任务示例
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();
        }
    }
}

七、性能对比

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

// 性能对比测试
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. 最佳实践

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

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

未来展望

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

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

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

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

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

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

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

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

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

阅读原文

Go语言 Java 微服务算法面试

版权声明：cnblogshot 发表于 2025-09-25 16:45:44。
转载请注明：进程、线程、协程、虚拟线程，傻傻分不清楚 | 程序员导航网

暂无评论

您必须登录才能参与评论！

立即登录

暂无评论...

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

前言

一、进程与线程

进程：独立的执行环境

线程：轻量级的执行单元

二、线程的深入剖析

1. 用户级线程（ULT）

2. 内核级线程（KLT）

3. 混合模型

三、协程

协程的本质

协程 vs 线程

四、虚拟线程

为什么需要虚拟线程？

虚拟线程的实现原理

虚拟线程的优势

五、虚拟线程如何工作？

Continuation的概念

虚拟线程的调度模型

六、不同场景下的选择

1. CPU密集型任务

2. IO密集型任务

3. 混合型任务

七、性能对比

总结

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

2. 选择指南

3. 最佳实践

未来展望

OI？原来这么简单-语法&算法入门篇

老板催：官网打不开！我用这套流程 6 分钟搞定

暂无评论

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

前言

一、进程与线程

进程：独立的执行环境

线程：轻量级的执行单元

二、线程的深入剖析

1. 用户级线程（ULT）

2. 内核级线程（KLT）

3. 混合模型

三、协程

协程的本质

协程 vs 线程

四、虚拟线程

为什么需要虚拟线程？

虚拟线程的实现原理

虚拟线程的优势

五、虚拟线程如何工作？

Continuation的概念

虚拟线程的调度模型

六、不同场景下的选择

1. CPU密集型任务

2. IO密集型任务

3. 混合型任务

七、性能对比

总结

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

2. 选择指南

3. 最佳实践

未来展望

OI？原来这么简单-语法&算法入门篇

老板催：官网打不开！我用这套流程 6 分钟搞定

暂无评论

收藏至：