Een ander type taakgroep is de geplande taakgroep. Afgaande op de naam kunnen we aannemen dat we dit type gebruiken om te plannen wanneer een bepaalde taak moet worden gestart.

Dit type service is handig wanneer we een taak hebben om een ​​activiteit te starten nadat enige tijd is verstreken of we een terugkerende taak willen plannen.

Om er een te gebruiken, noemen we Executors.newScheduledThreadPool(1) .

We zullen het later over de parameters hebben. Maar voor nu moeten we weten dat wanneer deze methode wordt aangeroepen, we een ScheduledExecutorService- object krijgen.

ScheduledExecutorService is een interface die ExecutorService uitbreidt .

De volgende methoden verschijnen in deze interface:

Methode Uitleg 

ScheduledFuture<?>
schedule(Runnable command,
                                  long delay, TimeUnit unit);
Creëert en voert een eenmalige actie uit die wordt uitgevoerd na de opgegeven vertraging. 

<V> ScheduledFuture<V>
schedule(Callable<V> callable,
                                      long delay, TimeUnit unit);
Creëert en voert eenScheduledFutureobject dat wordt uitgevoerd na een opgegeven vertraging. 

ScheduledFuture<?>
scheduleAtFixedRate(Runnable command,
                                             long initialDelay,
                                             long period,
                                             TimeUnit unit);
Creëert en voert een terugkerende actie uit die eerst wordt uitgevoerd na de opgegeven initiële vertraging en vervolgens opnieuw na de opgegeven periode. Met andere woorden, de uitvoering begint na initialDelay , dan initialDelay + period , dan initialDelay + 2 * period , enzovoort. 

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);
Creëert en voert een terugkerende actie uit die eerst wordt uitgevoerd na de opgegeven initiële vertraging, en vervolgens opnieuw met de opgegeven vertraging tussen de voltooiing van de ene uitvoering en het begin van de volgende.
Java webinar

Dus met de interface kunnen we taken met regelmatige tussenpozen of met enige vertraging uitvoeren.

Meer over de nieuweScheduledThreadPool-methode.

We kunnen het op verschillende manieren noemen:


newScheduledThreadPool(int corePoolSize)
corePoolSize is het aantal threads dat in de pool moet worden bewaard, zelfs als ze inactief zijn. 

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

corePoolSize is het aantal threads dat in de pool moet worden bewaard, zelfs als ze inactief zijn.

threadFactory is de fabriek die moet worden gebruikt bij het maken van nieuwe threads.

Beide methoden creëren een threadpool die acties kan plannen om na een bepaalde vertraging of periodiek uit te voeren.

Laten we een voorbeeld bekijken om te zien hoe ScheduledThreadPool werkt.

Stel dat we een taak hebben om elke 5 seconden e-mail te controleren, maar deze controle mag het hoofdprogramma niet beïnvloeden en brengt mogelijk extra bronnen met zich mee.

We hebben een taakklasse die het controleren van e-mail simuleert.


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

Vervolgens maken we een threadpool en plannen we de controle.


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

In de uitvoer zien we elke 5 seconden:

E-mail controleren...

Over het algemeen kunnen we zo'n pool gebruiken om periodieke "huishoudelijke" taken uit te voeren, zoals in het voorbeeld. Huishoudelijke taken zijn taken die moeten worden uitgevoerd ongeacht wat het hoofdprogramma aan het doen is.