Java thread pools are created using ThreadPoolExecutor, and you need to pay attention to the core parameter configuration. 1. The number of core threads controls the number of resident threads. It is recommended to set it to the number of CPU cores for calculation-intensive tasks; 2. The maximum number of threads should deal with burst traffic, and excessively high will increase thread switching overhead; 3. The task queue size needs to weigh the risk of memory usage and task loss; 4. The rejection strategy can be customized, such as throwing an exception or executing by the caller; 5. Shutdown should be called first and then combined with awaitTermination and shutdownNow to ensure safe exit. Directly using the Executors tool class can easily cause memory overflow. The submit() method supports obtaining task results. Future.get() is a blocking operation. Long-term tasks may cause threads to "fake death", so a timeout mechanism needs to be set to avoid it.

Thread pool implementation and management in Java are not advanced technologies, but if you don’t use them well, problems will easily arise. Although it is simple to directly create and destroy threads, it will cause considerable overhead. The rational use of thread pools can effectively control concurrent resources and improve system performance.

Basic creation of thread pools

Java provides the ExecutorService interface and Executors tool class to simplify the creation of thread pools. The most common way is to define a custom thread pool through ThreadPoolExecutor :

 ExecutorService executor = new ThreadPoolExecutor(
    5, // The number of core threads is 10, // The maximum number of threads is 60, // Idle thread survival time TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100) // Task Queue);

This method allows you to control thread pool behavior more granularly. For example, the number of core threads determines the number of resident threads, and the maximum number of threads is used to deal with burst traffic. The size of the task queue is also very critical. It is easy to lose tasks if it is too small, and it may occupy too much memory.

Common misunderstandings: Many people use Executors.newFixedThreadPool(10) directly. Although this method is convenient, its task queue is unbounded and may cause memory overflow.

How to submit tasks and process results

Thread pools are mainly used to perform Runnable or Callable types of tasks. The difference between the two is that Callable can return the result and throw an exception.

• Use execute() method to submit a Runnable task:

   executor.execute(() -> System.out.println("Execute a Runnable task"));

• Use submit() to get the execution result:

   Future<String> future = executor.submit(() -> "Task Complete");
  String result = future.get(); // Block until the result returns

Note that Future.get() is a blocking operation. If the task has not been completed, the calling thread will be suspended. If you need asynchronous callbacks or the result of combining multiple tasks, it is recommended to consider using CompletableFuture .

Properly configure parameters to avoid common problems

Improper thread pool configuration can lead to many problems, such as low CPU utilization, OOM (memory overflow), task accumulation, etc. Here are some practical suggestions:

• Number of core threads : Selected according to task type. If it is a computing-intensive task, it is usually set to the number of CPU cores; if it is an IO-intensive, it can be increased appropriately.
• Maximum number of threads : Don't set it too high, otherwise it will cause additional overhead due to thread switching.
• Reject policy : When the task queue is full and the number of threads reaches the maximum, the thread pool will trigger the reject policy, and the default is to throw exceptions. You can customize policies, such as logging or discarding tasks.

 new ThreadPoolExecutor.AbortPolicy() // Default policy, throw RejectedExecutionException
new ThreadPoolExecutor.CallerRunsPolicy() // Execute by the calling thread itself

A more common problem is that the thread pool "fake death" - all threads are waiting for a long task to be completed, and new tasks cannot be entered. This situation can be mitigated by limiting the task execution time or setting a timeout mechanism.

Close the thread pool correctly

The thread pool is not done when used, remember to close it when not in use. Otherwise, the JVM will not exit automatically, which may cause resource leakage.

• shutdown() : New tasks are no longer accepted, but submitted tasks will continue to be executed.
• shutdownNow() : Try to stop all tasks immediately, and there is no guarantee that the running thread will be successfully interrupted.

The recommended method is to call shutdown first, then wait for a while, and if there are still unfinished tasks, then consider force closing:

 executor.shutdown();
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
}

The process of closing the thread pool should consider whether the task can be interrupted, otherwise it may lead to data inconsistency and other problems.

Basically that's it. The thread pool itself is not complicated, but if it is used well, there are many details that need to be paid attention to.

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