Un alt tip de grup de activități este grupul de activități programate. Judecând după nume, putem presupune că folosim acest tip pentru a programa când trebuie lansată o anumită sarcină.

Acest tip de serviciu este util atunci când avem o sarcină pentru a lansa o activitate după ce a trecut ceva timp sau dorim să programăm o sarcină recurentă.

Pentru a folosi unul, numim Executors.newScheduledThreadPool(1) .

Vom vorbi despre parametri puțin mai târziu. Dar deocamdată, ceea ce trebuie să știm este că atunci când această metodă este apelată obținem un obiect ScheduledExecutorService .

ScheduledExecutorService este o interfață care extinde ExecutorService .

În această interfață apar următoarele metode:

Metodă Explicaţie 

ScheduledFuture<?>
schedule(Runnable command,
                                  long delay, TimeUnit unit);
Creează și execută o acțiune unică care rulează după întârzierea specificată. 

<V> ScheduledFuture<V>
schedule(Callable<V> callable,
                                      long delay, TimeUnit unit);
Creează și execută aScheduledFutureobiect care se execută după o întârziere specificată. 

ScheduledFuture<?>
scheduleAtFixedRate(Runnable command,
                                             long initialDelay,
                                             long period,
                                             TimeUnit unit);
Creează și execută o acțiune recurentă care rulează mai întâi după întârzierea inițială specificată și apoi din nou după perioada specificată. Cu alte cuvinte, execuția va începe după initialDelay , apoi initialDelay + period , apoi initialDelay + 2 * period și așa mai departe. 

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);
Creează și execută o acțiune recurentă care se execută mai întâi după întârzierea inițială specificată și apoi din nou cu întârzierea specificată între finalizarea unei execuții și începerea următoarei.
Java university

Deci, interfața ne permite să executăm sarcini la intervale regulate sau după o anumită întârziere.

Mai multe despre metoda newScheduledThreadPool.

Îl putem numi în mai multe moduri:


newScheduledThreadPool(int corePoolSize)
corePoolSize este numărul de fire care trebuie păstrate în pool, chiar dacă acestea sunt inactive. 

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

corePoolSize este numărul de fire care trebuie păstrate în pool, chiar dacă acestea sunt inactive.

threadFactory este fabrica de utilizat atunci când se creează fire noi.

Ambele metode vor crea un pool de fire care poate programa acțiuni pentru a fi executate după o întârziere specificată sau periodic.

Să ne uităm la un exemplu pentru a vedea cum funcționează ScheduledThreadPool .

De exemplu, să presupunem că avem o sarcină de a verifica e-mailul la fiecare 5 secunde, dar această verificare nu trebuie să afecteze programul principal și implică consumul potențial de resurse suplimentare.

Avem o clasă de activități care simulează verificarea e-mailului.


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

Apoi, creăm un pool de fire și programăm verificarea.


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

În ieșire, la fiecare 5 secunde vedem:

Se verifică e-mailul...

În general, putem folosi un astfel de bazin pentru a efectua sarcini periodice de „menaj”, ca în exemplu. Sarcinile de menaj sunt sarcini care trebuie efectuate indiferent de ceea ce face programul principal.