Java虚拟线程与线程池：为什么在虚拟线程池中复用虚拟线程会失败？

Java virtual threads and thread pools: In-depth collaborative mechanism analysis

This article analyzes the root cause of virtual threads not being able to execute normally in a virtual thread pool created using Executors.newVirtualThreadPerTaskExecutor() and provides an effective solution. The problem is clarified by comparing the two methods of methods5 and methods6 through code examples. methods6 (execute normal threads in normal thread pool) can print logs normally, while methods5 (trying to reuse pre-created virtual threads in virtual thread pool) fails.

methods5 attempts to repeatedly submit the same virtual thread object vt to the virtual thread pool. However, this goes against the design philosophy of Executors.newVirtualThreadPerTaskExecutor() . This thread pool is designed to create a new virtual thread for each task, rather than reusing existing threads. executor.submit(vt) method expects to receive Runnable or Callable objects, while vt is a Thread object, but is not Runnable or Callable , so it cannot be executed as expected.

The solution is as follows:

Solution 1: Directly submit Runnable object

Avoid pre-creating virtual threads and submitting Runnable objects directly to the virtual thread pool. The improved methods5 is as follows:

 private static void methods5() {
  try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
      for (int i = 0; i  {
              System.out.println("vt task executed.");
          });
      }
  }
}

This scheme submits lambda expressions as Runnable objects, making full use of the characteristics of virtual thread pools, and generates new virtual threads for each task.

Scheme 2: Use Thread object, but recreate it every time

Although not recommended, if you must use Thread objects, you should create a new Thread object every time you submit a task to avoid reuse. This method is inefficient and contrary to the original intention of designing virtual thread pools.

In addition, the article emphasizes that thread pooling is not a necessary optimization strategy for virtual threads, because the overhead of creating and destroying virtual threads is extremely low. Executors.newVirtualThreadPerTaskExecutor() itself has fully utilized the lightweight features of virtual threads. Too much pooling will increase management burden and reduce performance. Therefore, the method of directly using executor.submit(() -> { ... }); is more in line with the characteristics of virtual threads and is more concise and efficient.

The above is the detailed content of Java虚拟线程与线程池：为什么在虚拟线程池中复用虚拟线程会失败？. For more information, please follow other related articles on the PHP Chinese website!