协程/虚拟线程

协程/虚拟线程简介

1.   什么是协程/虚拟线程

       协程 （Coroutine） 是一种比线程更加轻量级的并发编程方式。它允许函数在执行过程中暂停，并且可以在稍后恢复执行。协程在许多编程语言中都有实现，比如Python、Kotlin、JavaScript等。

       虚拟 线程 （Virtual Thread ） 是JDK 19引入的一个新特性并在JDK21转正，它提供了比传统Java线程更加轻量的并发执行方式。

       下面统称协程

       协程（虚拟线程）的关键特性包括：

   • 轻量级：协程通常比线程更轻量，占用的资源更少，因为它们不需要操作系统级别的上下文切换。

   • 非抢占式调度：协程的切换是显式的，通过程序代码控制，而不是由操作系统抢占调度。

   • 适用于IO密集型任务：协程非常适合处理大量IO操作的任务，例如网络请求、文件读写等，因为它们在等待IO操作时可以挂起，而不会阻塞整个线程。

2.   既生线程何生协程？（线程和协程的区别）

   1. 线程（Thread）：

      1. 线程是操作系统级别的并发执行单元，每个线程都有自己的堆栈和程序计数器。
      2. 多线程通常使用操作系统的线程调度器来管理线程之间的切换，因此线程的切换会涉及一些开销。
      3. 线程通常适用于需要并行执行阻塞或 I/O 密集型任务的情况，如网络通信或文件读写操作。

   2. 协程（Coroutine）：

      1. 协程是用户级别的轻量级线程，通常由编程语言或库来实现，而不依赖于操作系统的线程。
      2. 协程之间的切换是由程序控制的，因此通常比线程切换更高效，减少了开销。
      3. 协程通常适用于需要高度并发、非阻塞、事件驱动的应用程序，如Web服务器、实时游戏服务器等。

       因此，要根据应用程序的需求来选择线程还是协程：

   • 如果 需要执行大量的 I/O 操作，而不希望线程切换带来太多开销，那么协程可能是更好的选择。
   • 如果 需要执行大量的计算密集型操作，那么线程可能更适合，它可以利用多核处理器实现真正的并行性。

3.   有什么是只能线程做，协程无法做的

   • 多核并行计算：如果要利用多核处理器执行计算密集型任务，线程通常更适合，因为线程可以在不同的核上并行执行任务，而协程通常在单个线程内执行。
   • 阻塞式的外部资源访问：如果你的应用程序需要频繁地与阻塞式的外部资源（如传统的同步文件 I/O、数据库查询）交互，线程可能更适合，因为线程可以在等待外部资源时切换到其他任务，从而提高并发性。
   • 并发数据结构和共享状态：线程更容易用于管理共享状态和并发数据结构，因为线程可以直接访问共享内存，而协程通常需要使用锁或其他同步机制来实现。

       尽管如此，可以通过合理的设计和结合不同的技术来克服这些限制。

       例如:将协程与线程结合使用，使用线程来处理多核计算任务，而使用协程来管理异步 I/O 操作

协程VS线程

1.   定义

线程

• 线程是操作系统级别的并发执行单元，每个线程都有自己的堆栈和程序计数器。
• 多线程通常使用操作系统的线程调度器来管理线程之间的切换，因此线程的切换会涉及一些开销。
• 线程通常适用于需要并行执行阻塞或 I/O 密集型任务的情况，如网络通信或文件读写操作

协程

• 协程是用户级别的轻量级线程，通常由编程语言或库来实现，而不依赖于操作系统的线程。

• 协程之间的切换是由程序控制的，因此通常比线程切换更高效，减少了开销。

• 协程通常适用于需要高度并发、非阻塞、事件驱动的应用程序，如Web服务器、实时游戏服务器等。

2.   适用场景

   • 如果 需要执行大量的 I/O 操作，而不希望线程切换带来太多开销，那么协程可能是更好的选择。
   • 如果 需要执行大量的计算密集型操作，那么线程可能更适合，它可以利用多核处理器实现真正的并行性。

3.    并发模型

   线程

   • 线程是并发的，多个线程可以同时运行在多核CPU上。
   • 线程适用于CPU密集型和IO密集型任务。
   • 线程间需要同步机制（如锁、信号量）来保护共享资源，避免竞争条件。

   协程

   • 协程是协作式并发的，通常在一个线程内运行，适用于IO密集型任务。
   • 协程通过异步操作（如网络请求、文件读写）实现并发，避免阻塞。
   • 协程的同步机制通常是轻量级的，如async/await、Promise等。

4.   并发模型

5.   资源消耗

   线程

   • 线程的创建和上下文切换开销较大，占用更多的内存和CPU资源。
   • 每个线程有独立的堆栈和寄存器状态，需要操作系统管理。

   协程

   • 协程的创建和上下文切换开销较小，占用更少的资源。
   • 协程通常在同一线程内运行，共享相同的堆栈和寄存器状态。

6.   JAVA虚拟线程运行对比

   1.     固定线程池

      • 测试代码

        • @SuppressWarnings("ALL")
          public class RealThreadTest {
          
              /**
          * 任务总数
          */
          private static final int TASK_COUNT = 100_000_00;
          
              /**
          * 并发任务数
          */
          private static final int THREAD_COUNT = 1000;
          
              /**
          * 主函数入口。
          * 创建一个固定大小的线程池，并提交多个任务到线程池中执行。
          * 每个任务简单地打印当前线程信息，并休眠10毫秒。
          * 任务执行完毕后，线程池会自动关闭。
          * <p>
          * 参数: args - 传入的命令行参数数组（在此示例中未使用）
          */
          public static void main(String[] args) {
          
                  // 创建一个包含1000个线程的固定大小线程池
                  ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
                  // 提交TASK_COUNT个任务到线程池
                  for (int i = 0; i < TASK_COUNT; i++) {
                      int finalI = i;
                      // 每个任务打印线程信息并休眠10毫秒
                      threadPool.submit(() -> {
                          try {
                              System.out.println("Thread " + finalI + " " + Thread.currentThread().getName() + " is running");
                              Thread.sleep(10);
                          } catch (InterruptedException e) {
                              // 线程休眠被中断，打印线程索引并重新设置中断状态
                              System.out.println(finalI);
                              Thread.currentThread().interrupt();
                          }
                      });
                  }
          
                  // 关闭线程池
                  threadPool.close();
                  // 注释掉的代码：原本计划在此处让主线程休眠1小时，但当前未使用
                  // TimeUnit.HOURS.sleep(1);
              }
          }
          

      • 运行占用资源

        • 任务量在10000000（千万） 并发（线程）数量在 1000（千）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 10000（万）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 2000（千）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 1000（千）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 100（百）

          • 

   2.     协程+信号量

      • 测试代码

        • public class VirtualThreadTest {
          
              /**
          * 任务总数
          */
          private static final int TASK_COUNT = 100_000_00;
          
              /**
          * 并发任务数
          */
          private static final int THREAD_COUNT = 1000;
          
              /**
          * 主函数示例，演示了如何使用Semaphore控制并发访问。
          * 使用一个Semaphore来限制同时运行的任务数量，通过虚拟线程池执行任务。
          * 每个任务在执行前后都会对Semaphore进行acquire和release操作。
          */
          public static void main(String[] args) throws InterruptedException {
                  // 创建一个Semaphore，允许1000个任务同时运行
                  Semaphore semaphore = new Semaphore(THREAD_COUNT);
          
                  try (ExecutorService virtualThreadPool = Executors.newVirtualThreadPerTaskExecutor()) {
                      // 循环提交TASK_COUNT个任务到线程池
                      for (int i = 0; i < TASK_COUNT; i++) {
                          int finalI = i;
                          // 获取Semaphore许可，如果所有许可都被占用则线程会等待
                          semaphore.acquire();
                          // 提交一个任务到虚拟线程池
                          virtualThreadPool.submit(() -> {
                              try {
                                  // 打印当前线程信息
                                  System.out.println("Thread " + finalI + " " + Thread.currentThread().threadId() + " is running");
                                  // 模拟任务执行时间
                                  Thread.sleep(10);
                              } catch (InterruptedException e) {
                                  // 如果线程在睡眠中被中断，打印线程编号并重新设置中断状态
                                  System.out.println(finalI);
                                  Thread.currentThread().interrupt();
                              } finally {
                                  // 无论任务执行结果如何，最后都释放Semaphore许可
                                  semaphore.release();
                              }
                          });
                      }
                  }
                  // 注释掉的代码是为了等待所有任务执行完成，这里不再需要因为线程池的关闭会阻塞直到所有任务完成
                  // TimeUnit.HOURS.sleep(1);
              }
          }
          

      • 运行占用资源

        • 任务量在10000000（千万） 并发（线程）数量在 1000（千）

          • 

        • 任务量在10000000（千万） 并发（线程）数量在 10000（万）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 2000（千）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 1000（千）

          • 

        • 任务量在1000000（百万） 并发（线程）数量在 100（百）

          • 

拓展问答