随笔记录

进程、线程、协程

2025-3-28 diaba 多线程

1. 进程（Process）

• 定义：进程是操作系统分配资源的基本单位，是程序的一次执行实例。每个进程都有独立的内存空间、代码段、数据段等资源。
• 特点：
  • 独立性：每个进程拥有独立的内存空间，进程之间的数据交换需要通过进程间通信（IPC）机制（如管道、消息队列、共享内存等）。
  • 重量级：创建和销毁进程的开销较大，因为需要分配和回收大量资源。
  • 隔离性：进程之间的隔离性较好，一个进程的崩溃不会影响其他进程。
• 适用场景：适合资源隔离要求高、任务相对独立的场景，如多任务操作系统中的不同应用程序。

2. 线程（Thread）

• 定义：线程是进程中的一个执行单元，是操作系统能够进行调度的最小单位。一个进程可以包含多个线程。
• 特点：
  • 轻量级：线程共享进程的内存空间，创建和销毁的开销较小。
  • 高并发：线程之间的切换速度较快，适合高并发场景。
  • 共享性：线程之间共享进程的资源，可以直接访问同一进程中的数据，但需要处理线程安全问题。
• 适用场景：适合需要高并发处理的场景，如服务器端编程、多任务处理等。

3. 协程（Coroutine）

• 定义：协程是一种用户态的轻量级线程，由程序自身进行调度，而不是由操作系统内核调度。
• 特点：
  • 极轻量级：创建和切换的开销极小，适合高并发场景。
  • 灵活调度：由程序自身控制协程的切换，可以更灵活地实现任务调度。
  • 非抢占式：协程的切换是非抢占式的，由程序显式调用切换点（如 yield）。
• 适用场景：适合高并发的I/O密集型任务，如网络编程、异步编程等。

Java中的使用

1. 进程

在Java中，可以通过 Runtime 或 ProcessBuilder 类来创建和管理进程。

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class ProcessExample {
    public static void main(String[] args) {
        try {
            // 创建一个进程
            Process process = Runtime.getRuntime().exec("notepad.exe");

            // 等待进程结束
            int exitCode = process.waitFor();
            System.out.println("进程退出码: " + exitCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 线程

在Java中，可以通过继承 Thread 类或实现 Runnable 接口来创建线程。

继承 Thread 类：

public class ThreadExample extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }

    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();
        thread.start(); // 启动线程
    }
}

实现 Runnable 接口：

public class RunnableExample implements Runnable {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }

    public static void main(String[] args) {
        RunnableExample task = new RunnableExample();
        Thread thread = new Thread(task);
        thread.start(); // 启动线程
    }
}

3. 协程

Java本身没有原生的协程支持，但可以通过第三方库（如 Quasar 或 Kotlin 的协程）来实现协程功能。

使用 Quasar 实现协程：

import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.Suspendable;

public class CoroutineExample {
    @Suspendable
    public static void fiberTask() {
        System.out.println("协程正在运行");
    }

    public static void main(String[] args) {
        Fiber<Void> fiber = new Fiber<>(CoroutineExample::fiberTask);
        fiber.start(); // 启动协程
        fiber.join();  // 等待协程结束
    }
}

使用 Kotlin 的协程：

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        println("协程正在运行")
    }
    Thread.sleep(1000) // 等待协程完成
}

总结

• 进程：适合资源隔离要求高的场景，但创建和切换开销较大。
• 线程：适合高并发处理的场景，但需要处理线程安全问题。
• 协程：适合高并发的I/O密集型任务，创建和切换开销极小，但需要额外的库支持。

在Java中，线程是主要的并发编程工具，而协程可以通过第三方库实现。