Maîtriser l'arrêt d'ExecutorService : suivi de la résiliation de ThreadPool

Disons que vous souhaitez exécuter certaines tâches. Étant donné que son exécution via un seul thread peut vous prendre un certain temps pour obtenir le résultat, vous décidez d'utiliser ExecutorService, toujours fiable, pour le traiter via plusieurs threads.

Voici un échantillon :

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        int temp = i;
        executorService.submit(() -> {
            task(temp);
        });
    }
    executorService.shutdown();
    System.out.println("ExecutorService is shutdown");
}

private static void task(int temp) {
    try {
        TimeUnit.SECONDS.sleep(1L);
        System.out.println("Task " + temp + " completed");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

Bien sûr, comme d'habitude, aucun exemple de Threads n'est jamais complet sans utiliser le « veille » comme archétype de l'exécution de tâches.

Il sort,

ExecutorService is shutdown
Task 1 completed
Task 2 completed
Task 0 completed
Task 4 completed
Task 3 completed

Imaginez maintenant qu'il y ait une file d'attente interminable de tâches, dont vous ne connaissez pas le nombre. Peut-être qu'ils sont déterminés par le nombre d'entrées dans une base de données qui sont ajoutées dynamiquement.

Par exemple, une banque, dans laquelle elle doit traiter un certain nombre de transactions tout au long de la journée. L'heure de fin de la transaction sera 17h00, au-delà de laquelle elle n'acceptera aucune tâche supplémentaire.

Cependant, vous savez que le nombre de tâches sera fini et sera terminé à un moment donné.

Comment connaître le moment où toutes les tâches sont terminées ?

Si vous remarquez l'extrait de code ci-dessus, ExecutorService.shutdown() permet au thread principal de se fermer immédiatement, mais les threads d'arrière-plan traitent toujours les tâches acceptées jusqu'à leur achèvement. Existe-t-il un moyen d'être informé de l'achèvement ?

Quelques solutions me viennent à l'esprit :

1. Utilisez un CountDownLatch pour compter les tâches - mais comme vous ne connaissez pas le nombre de tâches, il n'est pas pratique de l'utiliser.
2. Utilisez ExecutorService.awaitTermination(). Cependant, le moment est encore indéterminé. Vous pouvez utiliser un ExecutorService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS) très libéral ou quelque chose de similaire. Mais c'est encore une fois un appel bloquant.

Y a-t-il une meilleure façon de résoudre ce problème ?

Java offre un moyen meilleur et relativement inconnu de contourner ce problème. Le "truc" ici est de savoir qu'Executors.newFixedThreadPool est essentiellement un ThreadPoolExecutor avec des valeurs prédéfinies. Vérifions l'implémentation de Executors.newFixedThreadPool.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Je recommande vraiment de lire la doc de ThreadPoolExecutor ici. ExecutorService est un wrapper pratique sur ThreadPoolExecutor.

... les programmeurs sont invités à utiliser les méthodes d'usine Executors plus pratiques Executors.newCachedThreadPool() (pool de threads illimité, avec récupération automatique des threads), Executors.newFixedThreadPool(int) (pool de threads de taille fixe) et Executors.newSingleThreadExecutor( ) (un seul fil d'arrière-plan), qui préconfigure les paramètres pour les scénarios d'utilisation les plus courants.

La section qui nous aidera à résoudre le problème est :

Méthodes de crochet

Cette classe fournit des méthodes protégées et remplaçables beforeExecute(Thread, Runnable) et afterExecute(Runnable, Throwable) qui sont appelées avant et après l'exécution de chaque tâche. Ceux-ci peuvent être utilisés pour manipuler l’environnement d’exécution ; par exemple, réinitialiser ThreadLocals, collecter des statistiques ou ajouter des entrées de journal. De plus, la méthode terminated() peut être remplacée pour effectuer tout traitement spécial qui doit être effectué une fois l'exécuteur complètement terminé.

Nous pouvons utiliser la méthode terminée pour nous en informer ! Mais comment l'utiliser ?

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        int temp = i;
        executorService.submit(() -> {
            task(temp);
        });
    }
    executorService.shutdown();
    System.out.println("ExecutorService is shutdown");
}

private static void task(int temp) {
    try {
        TimeUnit.SECONDS.sleep(1L);
        System.out.println("Task " + temp + " completed");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

Si vous ne préférez pas les classes anonymes (comme moi), vous pouvez toujours étendre ThreadPoolExecutor vous-même pour en créer une personnalisée.

ExecutorService is shutdown
Task 1 completed
Task 2 completed
Task 0 completed
Task 4 completed
Task 3 completed

Voici le résultat pour vérifier s'il fonctionne selon nos attentes.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Quels autres extraits relativement inconnus utilisez-vous ? Faites-le moi savoir dans les commentaires !

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!