Comment implémenter un pool de threads évolutif dans la programmation simultanée Java ?

Le pool de threads évolutif en Java peut ajuster dynamiquement le nombre de threads en fonction de la demande et est créé à l'aide de la méthode newCachedThreadPool dans la classe Executors. Les propriétés configurables incluent le nombre de threads principaux, le nombre maximum de threads, le temps de rétention des threads inactifs et la fabrique de threads, qui peuvent être définis via les méthodes correspondantes. Dans le cas réel, le pool de threads évolutif est utilisé pour soumettre la liste des tâches et attendre que la tâche soit terminée.

Implémentation d'un pool de threads évolutif dans la programmation simultanée Java

Dans la programmation simultanée Java, le pool de threads est un outil courant pour gérer les threads. Un pool de threads bien conçu peut améliorer les performances, l'évolutivité et la disponibilité. Cet article présentera comment utiliser la classe Executors en Java pour créer et configurer un pool de threads évolutif, et fournira un cas pratique. Executors类创建和配置一个可扩展的线程池，并提供一个实战案例。

创建可扩展线程池

可扩展线程池的關鍵是要根据需求动态调整线程池中的线程数量。Java中的Executors类提供了创建可扩展线程池的方法：

ExecutorService executor = Executors.newCachedThreadPool();

newCachedThreadPool方法返回一个可扩展的线程池，它根据需要创建和销毁线程。如果队列中没有正在运行的任务，线程将被销毁，而当新的任务提交时，新的线程将被创建。

配置线程池

可扩展线程池可以通过设置以下属性進行配置：

• corePoolSize：最小线程数，无论系统负载如何，始终保持活动状态。
• maximumPoolSize：最大线程数，仅在队列已满时创建。
• keepAliveTime：多余线程保持活动的时间，单位为毫秒。
• threadFactory：用于创建新线程的工厂。

可以使用ThreadPoolExecutor类setCorePoolSize(int corePoolSize)、setMaximunPoolSize(int maximumPoolSize)、setKeepAliveTime(long keepAliveTime, TimeUnit unit)和setThreadFactory(ThreadFactory threadFactory)

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();
    }
}

• corePoolSize : Le nombre minimum de threads pour toujours rester actif quelle que soit la charge du système .
• maximumPoolSize : Nombre maximum de threads, créés uniquement lorsque la file d'attente est pleine.
• keepAliveTime : Durée pendant laquelle les threads redondants restent actifs, en millisecondes.
• threadFactory : Factory utilisée pour créer de nouveaux threads.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!