Java Virtual Threads and Thread Pools Interaction

Virtual threads can be used with thread pools. 1. The virtual thread is managed by the JVM and is scheduled and executed through the "carrier thread". Multiple virtual threads can switch and run on the same platform thread; 2. The virtual thread uses ForkJoinPool.commonPool() as the scheduler by default. After the task is submitted to the underlying thread pool, it is automatically scheduled by the JVM, and suspends and switches other virtual threads when blocked; 3. When using it, you need to pay attention to avoid manually limiting the size of the thread pool, do not misuse virtual threads to handle CPU-intensive tasks, and monitors the load of the thread pool.

Virtual Threads in Java are a major feature introduced by Project Loom, which greatly improves the throughput capabilities of concurrent programs. What many people are concerned about is: how does virtual threads cooperate with traditional thread pools (Thread Pools)? Can they be used together? The answer is yes, but there are some details to pay attention to.

The basic mechanism of virtual threads

Virtual threads are lightweight threads managed by the JVM. Unlike the kernel threads of the operating system, they are extremely low-cost to create and can easily create hundreds of thousands or even millions of concurrent execution units. They mainly schedule execution through a "carrier thread". Simply put, multiple virtual threads can be switched on the same platform thread (such as threads in the thread pool).

This means that you don't need to assign an operating system thread individually to each virtual thread . This design greatly improves resource utilization, especially in I/O-intensive tasks.

How do virtual threads interact with thread pools?

ExecutorService and thread pool in Java are still the infrastructure of many concurrent tasks. By default, virtual threads use ForkJoinPool.commonPool() as their scheduler. That is to say:

• When you call Thread.startVirtualThread(Runnable) or use Executors.newVirtualThreadPerTaskExecutor() to create virtual threads, the JVM will automatically submit these tasks to the underlying public thread pool.
• These tasks will be executed on a thread in the pool. When encountering a blockage (such as network, file reading and writing), the JVM will automatically suspend the current virtual thread and schedule other virtual threads to continue execution.

Therefore, you can understand it as: virtual threads do not replace thread pools, but implement higher density concurrency models based on thread pools .

Things to note when using thread pool

Although virtual threads can work well with thread pools, special attention should be paid to in some scenarios:

• Avoid manually limiting thread pool size
  If you explicitly create a fixed-size thread pool (such as newFixedThreadPool(10) ), the virtual thread scheduling will also be limited to these 10 threads. This can become a bottleneck, especially in the case of a lot of blocking operations.

• Don't mistakenly think that virtual threads can solve all performance problems
  If your task itself is CPU-intensive, using virtual threads will not bring significant improvements. This is more suitable for using traditional thread pools or parallel streams.

• Monitor thread pool load
  Although virtual threads are very light, if the underlying thread pool is insufficient, it will still lead to problems such as task queuing and increasing latency. The activity and queue length of the thread pool can be monitored through JMX or logs.

Let's summarize

Virtual threads and thread pools are not opposite relationships, but complementary. Virtual threads use the thread pool to complete scheduling, which greatly reduces resource consumption. If your application mainly deals with asynchronous/non-blocking tasks, such as web requests, database access, etc., then you can completely replace the traditional thread pool with an executor that supports virtual threads.

Basically that's it.

The above is the detailed content of Java Virtual Threads and Thread Pools Interaction. For more information, please follow other related articles on the PHP Chinese website!