Un autre type de pool de tâches est le pool de tâches planifiées. À en juger par le nom, nous pouvons supposer que nous utilisons ce type pour planifier le lancement d'une tâche particulière.

Ce type de service est utile lorsque nous avons une tâche pour lancer une activité après un certain temps ou que nous voulons planifier une tâche récurrente.

Pour en utiliser un, nous appelons Executors.newScheduledThreadPool(1) .

Nous parlerons des paramètres un peu plus tard. Mais pour l'instant, ce que nous devons savoir, c'est que lorsque cette méthode est appelée, nous obtenons un objet ScheduledExecutorService .

ScheduledExecutorService est une interface qui étend ExecutorService .

Les méthodes suivantes apparaissent dans cette interface :

Méthode Explication 

ScheduledFuture<?>
schedule(Runnable command,
                                  long delay, TimeUnit unit);
Crée et exécute une action ponctuelle qui s'exécute après le délai spécifié. 

<V> ScheduledFuture<V>
schedule(Callable<V> callable,
                                      long delay, TimeUnit unit);
Crée et exécute unPlanifiéFuturobjet qui s'exécute après un délai spécifié. 

ScheduledFuture<?>
scheduleAtFixedRate(Runnable command,
                                             long initialDelay,
                                             long period,
                                             TimeUnit unit);
Crée et exécute une action récurrente qui s'exécute d'abord après le délai initial spécifié, puis à nouveau après la période spécifiée. En d'autres termes, l'exécution commencera après initialDelay , puis initialDelay + period , puis initialDelay + 2 * period , et ainsi de suite. 

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);
Crée et exécute une action récurrente qui s'exécute d'abord après le délai initial spécifié, puis à nouveau avec le délai spécifié entre la fin d'une exécution et le début de la suivante.
Java university

Ainsi, l'interface nous permet d'exécuter des tâches à intervalles réguliers ou après un certain délai.

En savoir plus sur la méthode newScheduledThreadPool.

On peut l'appeler de plusieurs manières :


newScheduledThreadPool(int corePoolSize)
corePoolSize est le nombre de threads à conserver dans le pool, même s'ils sont inactifs. 

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

corePoolSize est le nombre de threads à conserver dans le pool, même s'ils sont inactifs.

threadFactory est la fabrique à utiliser lors de la création de nouveaux threads.

Les deux méthodes créeront un pool de threads qui peut planifier des actions à exécuter après un délai spécifié ou périodiquement.

Regardons un exemple pour voir comment fonctionne ScheduledThreadPool .

Par exemple, supposons que nous ayons pour tâche de vérifier les e-mails toutes les 5 secondes, mais cette vérification ne doit pas affecter le programme principal et entraîne la consommation potentielle de ressources supplémentaires.

Nous avons une classe de tâches qui simule la vérification des e-mails.


public class Task implements Runnable {
   @Override
   public void run() {
       System.out.println("Checking email...");
   }
}

Ensuite, nous créons un pool de threads et planifions la vérification.


ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
executorService.scheduleAtFixedRate(new Task(), 0, 5, TimeUnit.SECONDS);

Dans la sortie, toutes les 5 secondes, nous voyons :

Vérification des e-mails...

En général, on peut utiliser un tel pool pour effectuer des tâches périodiques de « ménage », comme dans l'exemple. Les tâches d'entretien ménager sont des tâches qui doivent être effectuées indépendamment de ce que fait le programme principal.