Service d'exécution planifié avec un seul thread

Sep 02 2020

J'ai un exemple de code pour Scheduled Executor Service, tiré du site d'Oracle. Il crée un ScheduledExecutorService avec une taille de pool de base o 1. Il effectue 2 travaux: il démarre d'abord une tâche répétée exécutée à intervalles fixes, puis il tue la même tâche et le service lui-même après un délai.

 ScheduledExecutorService scheduledService = Executors.newScheduledThreadPool(1);
         //This will keep executing the task at fixed interval
         ScheduledFuture<?> futureTask = scheduledService.scheduleAtFixedRate(new RepeatedTask(), initialDelay, interval, TimeUnit.SECONDS);
         //A future task is returned which can be used to cancel the execution after sometime
         //Here we will cancel our repeated task after 100 seconds
         scheduledService.schedule(new TaskStopper(futureTask, scheduledService), 100, TimeUnit.SECONDS);

Le code de tâche répété:

public class RepeatedTask implements Runnable{
    int count = 0;
    @Override
    public void run() {
        count++;
        System.out.println(count + ". Beep");
    }

}

La tâche d'arrêt

@Override
    public void run() {
        mFutureTask.cancel(true);
        System.out.println("Task stopped");
        mExecutorService.shutdownNow();
        boolean shutDown = mExecutorService.isShutdown();
        if(shutDown) {
            System.out.println("Executor shutdown");
        }else {
            System.out.println("Executor not shutdown");
        }
    }

Je veux comprendre, comment cela fonctionne avec un seul thread dans le pool de threads. Puisque notre service exécuteur exécute deux tâches et les démarre tous les deux presque en même temps, ne devrions-nous pas avoir 2 threads, c'est-à-dire un ScheduledExecutorService avec une taille de pool de base de 2.

Cela fonctionne bien cependant. Je veux juste comprendre pourquoi cela fonctionne bien avec un seul thread.

Réponses

2 RishabhSharma Sep 02 2020 at 08:44

Pour tout pool de threads (y compris ScheduledThreadPool), le nombre de threads peut être inférieur au nombre de tâches. Les pools de threads ont en interne une file d'attente de tâches, dans laquelle une tâche devra attendre si aucun thread n'est disponible pour exécuter la tâche.

Dans votre exemple, à t = 100 secondes, deux tâches doivent être exécutées. Puisqu'un seul thread est disponible, il exécute la première tâche (tandis que la seconde attend dans la file d'attente). Une fois la première tâche terminée, le thread sélectionne la deuxième tâche dans la file d'attente et la termine.

Vous pouvez imprimer l'ID de thread dans les deux tâches et vérifier qu'ils sont bien traités par le même thread.

Edit: Donc, la tâche planifiée à intervalle fixe est exécutée plusieurs fois avec des intervalles fixes entre les deux. Pendant ces intervalles, notre thread unique dans le pool est inactif et est capable de choisir d'autres tâches à exécuter. C'est ainsi qu'un seul thread exécute les deux tâches.