一文读懂进程、线程、协程、纤程和Virtual Threads之间的区别与关系

原创

疯狂的KK

修改于 2024-02-20 16:48:45

71906

代码可运行

修改于 2024-02-20 16:48:45

文章被收录于专栏：Java项目实战Java项目实战

运行总次数：6

代码可运行

引言

在多线程编程和并发处理中，我们经常会听到进程、线程、协程、纤程和Virtual Threads这些概念。虽然它们都与并发编程相关，但很多人对它们的区别和关系并不清楚。本文将深入解析进程、线程、协程、纤程和Virtual Threads之间的区别与关系，帮助读者更好地理解并发编程的不同概念。

1. 进程(Process)

进程是计算机中运行的程序的实例。每个进程都有自己独立的内存空间和系统资源，并且可以拥有多个线程。进程之间是相互独立的，它们不能直接共享数据，必须通过进程间通信(IPC)来实现数据交换。

下面是一个简单的Java代码示例，展示了如何创建一个进程：

public class ProcessDemo {
    public static void main(String[] args) {
        ProcessBuilder processBuilder = new ProcessBuilder("myProgram.exe");
        try {
            Process process = processBuilder.start();
            // 等待进程执行完成
            int exitCode = process.waitFor();
            System.out.println("进程执行完成，退出码：" + exitCode);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们使用Java的ProcessBuilder类创建了一个进程，并执行了名为myProgram.exe的程序。

2. 线程(Thread)

线程是指在一个进程内执行的独立执行路径。一个进程可以包含多个线程，每个线程都是独立运行的，有自己的执行顺序和状态。

线程的特点包括：

轻量级：相比于进程，线程是更轻量级的执行单元。创建和销毁线程的开销较小，可以在短时间内创建大量线程。
共享资源：线程在同一个进程内共享进程的内存空间和系统资源。这意味着多个线程可以直接访问和修改同一份数据，更容易实现数据共享和通信。
并发执行：多个线程可以并发执行，实现任务的同时进行。不同线程之间可以按照特定的调度算法分配CPU时间片，从而实现并发处理。
上下文切换：由于线程是并发执行的，操作系统需要在不同线程之间进行上下文切换。上下文切换是指将一个线程的执行状态保存起来，并恢复另一个线程的执行状态，这个过程会带来一定的开销。
线程同步：多个线程访问共享资源时可能会出现竞态条件和数据不一致的问题。为了保证数据的一致性和正确性，需要使用线程同步机制，如互斥锁、信号量、条件变量等。
可以实现并行性：在多核处理器上，多个线程可以并行执行，提高程序的执行效率。通过线程的并行执行，可以将任务划分为多个子任务并同时进行处理，加快任务的完成速度。

总而言之，线程是一种轻量级的执行单元，它可以并发执行并共享进程的资源。通过合理地使用线程，我们可以充分发挥计算机的处理能力，提高程序的执行效率和响应速度。

线程是进程内的执行单元，它是CPU调度的基本单位。每个线程都运行在进程的上下文中，共享进程的内存空间和系统资源。线程之间可以直接共享数据，因此线程间通信更加高效。

线程的创建与销毁

2. 线程的创建

Java中线程的创建可以通过两种方式实现：继承Thread类和实现Runnable接口。接下来我们将逐一介绍这两种方式。

2.1 继承Thread类

首先我们来看一下通过继承Thread类创建线程的方式。具体步骤如下：

创建一个新的类，继承自Thread类，并重写run()方法。run()方法中包含了线程的执行逻辑。

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程的执行逻辑
    }
}

创建该类的实例，并调用start()方法启动线程。

MyThread myThread = new MyThread();
myThread.start();

通过这种方式，我们可以创建一个新的线程，并在其中定义线程的执行逻辑。

2.2 实现Runnable接口

除了继承Thread类，我们还可以通过实现Runnable接口来创建线程。具体步骤如下：

创建一个实现了Runnable接口的类，并实现run()方法。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程的执行逻辑
    }
}

创建该类的实例，并将其作为参数传递给Thread类的构造方法。

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

通过实现Runnable接口，我们可以将线程的执行逻辑独立出来，提高代码的复用性和可扩展性。

3. 线程的销毁

线程的销毁是指线程的执行结束以及释放相关资源的过程。Java中线程的销毁通常是自动进行的，但我们也可以通过一些手段来主动销毁线程。

3.1 线程的自动销毁

当线程的run()方法执行结束或抛出未捕获的异常时，线程将自动销毁。此时，线程的状态将变为终止状态（TERMINATED）。

Thread thread = new Thread(() -> {
    // 线程的执行逻辑
});
thread.start();

// 等待线程执行结束
thread.join();

// 判断线程是否已经销毁
if (thread.getState() == Thread.State.TERMINATED) {
    System.out.println("线程已销毁");
}

3.2 线程的主动销毁

有时候，我们需要在某个特定的条件下主动销毁线程。Java中提供了一些方法来实现线程的主动销毁。

3.2.1 使用标志位

我们可以在线程的执行逻辑中设置一个标志位，通过检查该标志位来决定是否继续执行。当标志位为false时，线程会主动退出循环，从而实现线程的主动销毁。

public class MyThread implements Runnable {
    private volatile boolean isRunning = true;

    @Override
    public void run() {
        while (isRunning) {
            // 线程的执行逻辑
        }
    }

    public void stopThread() {
        isRunning = false;
    }
}

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

// 在某个条件下主动销毁线程
myThread.stopThread();

在上面的例子中，我们在MyThread类中添加了一个boolean类型的标志位isRunning。在线程的执行逻辑中，我们通过检查该标志位来决定是否继续执行。当需要主动销毁线程时，我们调用stopThread()方法将isRunning设置为false，从而使线程退出循环。

3.2.2 使用interrupt()方法

另一种线程的主动销毁方式是使用interrupt()方法。该方法会中断线程的执行，并抛出一个InterruptedException异常。

public class MyThread implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 线程的执行逻辑
        }
    }
}

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

// 在某个条件下主动销毁线程
thread.interrupt();

在上述示例中，我们在线程的执行逻辑中使用了Thread.currentThread().isInterrupted()来检查线程是否被中断。当我们调用thread.interrupt()方法时，线程的isInterrupted()方法会返回true，从而使线程退出循环。

进程与线程的调度与同步

在开始之前，我们先来回顾一下进程和线程的基本概念。进程是指正在运行的程序的实例，它拥有独立的内存空间和资源。线程是进程内的执行单元，一个进程可以包含多个线程，它们共享进程的内存空间和资源。在Java中，进程由JVM管理，而线程由操作系统调度。

2. 进程与线程的调度

2.1 进程的调度

在操作系统中，进程调度是指操作系统按照一定的策略从就绪队列中选择一个进程分配CPU资源。Java中的进程调度是由操作系统负责的，我们无法直接控制进程的调度。操作系统根据进程的优先级、调度算法等因素来决定哪个进程获得CPU的执行时间。

2.2 线程的调度

线程调度是指操作系统按照一定的策略从就绪队列中选择一个线程分配CPU资源。Java提供了一些机制来影响线程的调度。

2.2.1 线程优先级

每个线程都有一个优先级，用来决定线程在竞争CPU资源时的执行顺序。Java中的线程优先级范围从1到10，默认为5。可以使用Thread.setPriority()方法设置线程的优先级。

Thread thread1 = new Thread(() -> {
    // 线程1的执行逻辑
});
Thread thread2 = new Thread(() -> {
    // 线程2的执行逻辑
});

thread1.setPriority(Thread.MAX_PRIORITY); // 设置线程1的优先级为最高
thread2.setPriority(Thread.MIN_PRIORITY); // 设置线程2的优先级为最低

thread1.start();
thread2.start();

线程的优先级只是一个提示，并不能保证按照优先级顺序执行。具体的线程调度由操作系统决定。

2.2.2 线程休眠

通过调用Thread.sleep()方法，我们可以让当前线程进入休眠状态，暂停一段时间后再继续执行。

Thread thread = new Thread(() -> {
    // 线程的执行逻辑
    try {
        Thread.sleep(1000); // 休眠1秒
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

线程休眠可以用来模拟一些需要等待的场景，或者调整线程执行的时间间隔。

3. 进程与线程的同步

在多线程编程中，线程之间的执行是并发的，可能会出现一些同步问题，例如竞态条件和死锁。Java提供了一些机制来帮助我们解决这些问题。

3.1 临界区

临界区是指一个程序片段，多个线程同时访问该片段时可能引发竞态条件的区域。为了保证临界区的互斥访问，我们可以使用synchronized关键字来修饰方法或代码块。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }
}

在上述例子中，increment()和decrement()方法被synchronized修饰，保证了对count变量的访问是互斥的，避免了竞态条件的发生。

3.2 线程通信

线程通信是指多个线程之间通过共享的对象来进行信息交换和同步。Java提供了wait()、notify()和notifyAll()方法来实现线程之间的通信。

public class Message {
    private String content;
    private boolean isReady;

    public synchronized void setContent(String content) {
        while (isReady) {
            try {
                wait(); // 等待消息被消费
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.content = content;
        isReady = true;
        notifyAll(); // 通知其他线程消息已经准备好
    }

    public synchronized String getContent() {
        while (!isReady) {
            try {
                wait(); // 等待消息被生产
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isReady = false;
        notifyAll(); // 通知其他线程消息已经被消费
        return content;
    }
}

在上述例子中，setContent()和getContent()方法使用了synchronized修饰，确保了线程之间的同步。当生产者线程调用setContent()方法时，如果消息已经准备好，则进入等待状态；否则设置消息内容、标记消息已经准备好，并通知其他线程。消费者线程调用getContent()方法时，如果消息还未准备好，则进入等待状态；否则获取消息内容、标记消息已被消费，并通知其他线程。

下面是一个简单的Java代码示例，展示了如何创建和启动一个线程：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程执行完成");
        });
        thread.start();
        System.out.println("主线程继续执行");
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ComplexMultithreadingExample {
    public static void main(String[] args) {
        // 创建一个包含5个线程的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 创建10个任务并提交给线程池执行
        for (int i = 0; i < 10; i++) {
            Runnable task = new MyTask(i);
            executor.submit(task);
        }

        // 关闭线程池
        executor.shutdown();
    }
}

class MyTask implements Runnable {
    private int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " started.");

        try {
            // 模拟任务执行时间
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Task " + taskId + " completed.");
    }
}

在上述代码中，我们创建了一个线程，并在线程中执行了一些任务。主线程和子线程可以并发执行，它们之间的执行顺序是不确定的。

3. 协程(Coroutine)

协程是一种更轻量级的线程，它可以在不同的执行点之间切换，而不是依赖于操作系统的线程调度。协程的切换是由程序员显式控制的，可以在需要的时候进行切换，提高并发性能。

下面是一个简单的Python代码示例，展示了如何使用协程：

import asyncio

async def myCoroutine():
    print("协程开始执行")
    await asyncio.sleep(1)
    print("协程执行完成")

asyncio.run(myCoroutine())

在上述代码中，我们使用Python的asyncio库创建了一个协程，并在协程中执行了一些任务。通过await关键字，我们可以暂停协程的执行，等待某个操作完成后再继续执行。

4. 纤程(Fiber)

纤程是一种用户态的轻量级线程，它由用户程序自己调度，不依赖于操作系统的线程调度。纤程可以在同一个线程内切换执行，减少了线程切换的开销，提高了并发处理的效率。

下面是一个简单的C++代码示例，展示了如何使用纤程：

#includesys/ucontext.h>

ucontext_t context[2];

void fiber1() {
    printf("纤程1开始执行\n");
    swapcontext(&context[1], &context[0]);
    printf("纤程1继续执行\n");
    swapcontext(&context[1], &context[0]);
    printf("纤程1执行完成\n");
}

void fiber2() {
    printf("纤程2开始执行\n");
    swapcontext(&context[0], &context[1]);
    printf("纤程2继续执行\n");
    swapcontext(&context[0], &context[1]);
    printf("纤程2执行完成\n");
}

int main() {
    char stack1[8192];
    char stack2[8192];

    getcontext(&context[0]);
    context[0].uc_stack.ss_sp = stack1;
    context[0].uc_stack.ss_size = sizeof(stack1);
    context[0].uc_link = &context[1];
    makecontext(&context[0], fiber1, 0);

    getcontext(&context[1]);
    context[1].uc_stack.ss_sp = stack2;
    context[1].uc_stack.ss_size = sizeof(stack2);
    context[1].uc_link = &context[0];
    makecontext(&context[1], fiber2, 0);

    printf("主线程开始执行\n");
    swapcontext(&context[0], &context[1]);
    printf("主线程继续执行\n");
    swapcontext(&context[0], &context[1]);
    printf("主线程执行完成\n");

    return 0;
}

在上述代码中，我们使用C++的ucontext库创建了两个纤程，并在纤程之间进行了切换。通过swapcontext函数，我们可以手动控制纤程的切换。

5. Virtual Threads

Virtual Threads是一种新型的并发模型，它是在Java虚拟机层面实现的轻量级线程。Virtual Threads可以在同一个线程内创建和调度大量的虚拟线程，避免了传统线程模型中线程数量过多导致的上下文切换开销。

应用场景

下面是一个简单的Java代码示例，展示了如何使用Virtual Threads：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class VirtualThreadDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newVirtualThreadExecutor();
        for (int i = 0; i < 10; i++) {
            int taskId = i;
            executorService.execute(() -> {
                System.out.println("虚拟线程" + taskId + "开始执行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("虚拟线程" + taskId + "执行完成");
            });
        }
        executorService.shutdown();
    }
}

在上述代码中，我们使用Java的Executors类创建了一个Virtual Threads的线程池，并在其中创建了10个虚拟线程进行并发执行。

Java中的Virtual Threads 该怎么使用

1. Virtual Threads的概述

Virtual Threads是Java 17中引入的一项新功能，它是一种轻量级的并发执行模型。与传统的线程相比，Virtual Threads具有更小的内存开销和更高的并发性能。它通过在一个或多个物理线程上运行多个虚拟线程来实现并发执行。

Virtual Threads的核心概念是Continuation，即继续执行的上下文。每一个Virtual Thread都包含一个Continuation，它可以被暂停和恢复。当Virtual Thread被暂停时，其状态将被保存，而不会占用物理线程的资源。当Virtual Thread被恢复时，它会从上次暂停的位置继续执行。

2. 使用Virtual Threads

Thread.setPriority(int) 和 Thread.setDaemon(boolean) 这俩方法对虚拟线程不起作用
Thread.getThreadGroup() 会返回一个虚拟的空VirtualThreads group。
同一个任务使用Virtual Threads和Platform Threads执行效率上是完全一样的，并不会有什么性能上的提升
尽量使用JUC包下的并发控制例如ReentrantLock来进行同步控制，而不使用synchronized 。 synchronized 同步代码块会pinning（别住或者说Block）虚拟线程，这点JDK官方说后面有可能会优化这点
Virtual Threads 被设计成final类，并不能使用子类来继承
不适用于计算密集型任务：虚拟线程适用于I/O密集型任务，但不适用于计算密集型任务，因为它们在同一线程中运行，可能会阻塞其他虚拟线程。新特性自然有很多BUG，这点在JDK的Issue中确实也体现了，使用请慎重！！

2.1 环境准备

在开始使用Virtual Threads之前，我们需要确保使用的是Java 17及以上的版本。可以通过以下代码验证Java版本：

public class JavaVersionCheck {
    public static void main(String[] args) {
        String javaVersion = System.getProperty("java.version");
        System.out.println("Java Version: " + javaVersion);
    }
}

2.2 创建Virtual Thread

使用Virtual Threads需要导入java.lang.VirtualThread类。我们可以通过以下代码创建一个Virtual Thread：

import java.lang.VirtualThread;

public class VirtualThreadDemo {
    public static void main(String[] args) {
        VirtualThread virtualThread = new VirtualThread(() -> {
            // Virtual Thread的执行逻辑
        });
        
        virtualThread.start();
    }
}

在上述代码中，我们通过VirtualThread类创建了一个Virtual Thread，并传入了一个Lambda表达式作为Virtual Thread的执行逻辑。然后我们调用start()方法启动该Virtual Thread。

2.3 Virtual Thread的暂停与恢复

Virtual Thread可以通过调用VirtualThread.yield()方法来主动暂停自己的执行。在暂停后，Virtual Thread的状态将被保存，等待被下一次调度执行。

import java.lang.VirtualThread;

public class VirtualThreadDemo {
    public static void main(String[] args) {
        VirtualThread virtualThread = new VirtualThread(() -> {
            // Virtual Thread的执行逻辑
            System.out.println("Virtual Thread: Hello, world!");
            VirtualThread.yield(); // 暂停Virtual Thread的执行
            System.out.println("Virtual Thread: Goodbye!");
        });
        
        virtualThread.start();
    }
}

在上述代码中，Virtual Thread首先打印一条消息，然后调用VirtualThread.yield()方法暂停自己的执行。在下一次调度时，Virtual Thread会从上次暂停的位置继续执行，并打印另一条消息。