How to implement scalable thread pool in Java concurrent programming?

The scalable thread pool in Java can dynamically adjust the number of threads according to needs and is created using the newCachedThreadPool method in the Executors class. Configurable properties include the number of core threads, the maximum number of threads, idle thread retention time and thread factory, which can be set through the corresponding methods. In the actual case, the scalable thread pool is used to submit the task list and wait for the task to be completed.

Implementation of scalable thread pool in Java concurrent programming

In Java concurrent programming, the thread pool is a common tool for managing threads. A well-designed thread pool can improve performance, scalability, and availability. This article will introduce how to use the Executors class in Java to create and configure a scalable thread pool, and provide a practical case.

Create a scalable thread pool

The key to a scalable thread pool is to dynamically adjust the number of threads in the thread pool according to demand. The Executors class in Java provides methods for creating an extensible thread pool:

ExecutorService executor = Executors.newCachedThreadPool();

newCachedThreadPoolThe method returns an extensible thread pool that is created and destroyed as needed thread. If there are no running tasks in the queue, the thread will be destroyed, and when a new task is submitted, a new thread will be created.

Configuring the thread pool

The scalable thread pool can be configured by setting the following properties:

• corePoolSize: Minimum number of threads, regardless of system No matter what the load, it's always active.
• maximumPoolSize: Maximum number of threads, created only when the queue is full.
• keepAliveTime: The time for excess threads to remain active, in milliseconds.
• threadFactory: Factory used to create new threads.

You can use ThreadPoolExecutor classsetCorePoolSize(int corePoolSize)、setMaximunPoolSize(int maximumPoolSize)、setKeepAliveTime(long keepAliveTime , TimeUnit unit) and setThreadFactory(ThreadFactory threadFactory) methods set these properties.

Practical Case

The following is a practical case using a scalable thread pool:

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Example {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        List<Callable<Integer>> tasks = List.of(
            () -> { return 1; },
            () -> { return 2; },
            () -> { return 3; }
        );

        List<Future<Integer>> results = executor.invokeAll(tasks);

        for (Future<Integer> result : results) {
            System.out.println(result.get());
        }

        executor.shutdown();
    }
}

In this example, we create a scalable thread pool in which threads The number is adjusted based on the number of tasks submitted. It submits a list of tasks and waits for all tasks to be completed. Finally, it closes the thread pool.

The above is the detailed content of How to implement scalable thread pool in Java concurrent programming?. For more information, please follow other related articles on the PHP Chinese website!