ScheduledThreadPoolExecutor Classe

java.util.concurrent.ScheduledThreadPoolExecutor è una sottoclasse di ThreadPoolExecutor e può inoltre pianificare l'esecuzione di comandi dopo un determinato ritardo o l'esecuzione periodica.

Metodi ScheduledThreadPoolExecutor

Sr.No. Metodo e descrizione
1

protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task)

Modifica o sostituisce l'attività utilizzata per eseguire un richiamabile.
2

protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)

Modifica o sostituisce l'attività utilizzata per eseguire un eseguibile.
3

void execute(Runnable command)

Esegue il comando con zero ritardo richiesto.
4

boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()

Ottiene il criterio se continuare a eseguire attività periodiche esistenti anche quando questo esecutore è stato arrestato.
5

boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()

Ottiene il criterio se eseguire le attività ritardate esistenti anche quando questo esecutore è stato arrestato.
6

BlockingQueue<Runnable> getQueue()

Restituisce la coda delle attività utilizzata da questo esecutore.
7

boolean getRemoveOnCancelPolicy()

Ottiene il criterio per stabilire se le attività annullate devono essere rimosse immediatamente dalla coda di lavoro al momento dell'annullamento.
8

<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)

Crea ed esegue un ScheduledFuture che viene abilitato dopo il ritardo specificato.
9

ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

Crea ed esegue un'azione one-shot che viene abilitata dopo il ritardo specificato.
10

ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

Crea ed esegue un'azione periodica che viene abilitata prima dopo il dato ritardo iniziale e successivamente con il dato periodo; cioè le esecuzioni inizieranno dopo initialDelay, quindi initialDelay + period, quindi initialDelay + 2 * period e così via.
11

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

Crea ed esegue un'azione periodica che viene abilitata prima dopo il ritardo iniziale dato, e successivamente con il ritardo dato tra la fine di un'esecuzione e l'inizio della successiva.
12

void setContinueExistingPeriodicTasksAfterShutdownPolicy (boolean value)

Imposta il criterio se continuare a eseguire attività periodiche esistenti anche quando questo esecutore è stato arrestato.
13

void setExecuteExistingDelayedTasksAfterShutdownPolicy (boolean value)

Imposta la politica sull'esecuzione delle attività ritardate esistenti anche quando questo esecutore è stato arrestato.
14

void setRemoveOnCancelPolicy(boolean value)

Imposta il criterio se le attività annullate devono essere rimosse immediatamente dalla coda di lavoro al momento dell'annullamento.
15

void shutdown()

Avvia un arresto ordinato in cui vengono eseguite le attività inoltrate in precedenza, ma non verranno accettate nuove attività.
16

List<Runnable> shutdownNow()

Tenta di interrompere tutte le attività in esecuzione attiva, interrompe l'elaborazione delle attività in attesa e restituisce un elenco delle attività in attesa di esecuzione.
17

<T> Future<T> submit(Callable<T> task)

Invia un'attività di restituzione del valore per l'esecuzione e restituisce un Future che rappresenta i risultati in sospeso dell'attività.
18

Future<?> submit(Runnable task)

Invia un'attività eseguibile per l'esecuzione e restituisce un Future che rappresenta tale attività.
19

<T> Future<T> submit(Runnable task, T result)

Invia un'attività eseguibile per l'esecuzione e restituisce un Future che rappresenta tale attività.

Esempio

Il seguente programma TestThread mostra l'utilizzo dell'interfaccia ScheduledThreadPoolExecutor in un ambiente basato su thread.

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException {
      final ScheduledThreadPoolExecutor scheduler = 
         (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(1);

      final ScheduledFuture<?> beepHandler = 
         scheduler.scheduleAtFixedRate(new BeepTask(), 2, 2, TimeUnit.SECONDS);

      scheduler.schedule(new Runnable() {

         @Override
         public void run() {
            beepHandler.cancel(true);
            scheduler.shutdown();			
         }
      }, 10, TimeUnit.SECONDS);
   }  

   static class BeepTask implements Runnable {
      
      public void run() {
         System.out.println("beep");      
      }
   }
}

Questo produrrà il seguente risultato.

Produzione

beep
beep
beep
beep