Servizi esecutori

Esecutore

Executor è l'interfaccia di base per le classi che implementa l'avvio di attività eseguibili . Ciò fornisce assistenza per l'aggiunta di un'attività e come avviarla.

ExecutorService è un'interfaccia che estende le proprietà di Executor e che descrive un servizio per l'esecuzione di attività eseguibili o richiamabili . I metodi submit accettano un'attività sotto forma di Callable o Runnable come input e Future viene utilizzato come valore di ritorno, attraverso il quale è possibile ottenere il risultato.

Il metodo invokeAll è responsabile dell'esecuzione delle attività, restituendo un elenco di attività con il relativo stato e i risultati di completamento.

Il metodo invokeAny è responsabile dell'esecuzione delle attività, restituendo il risultato di un'attività completata correttamente (ovvero senza generare un'eccezione), se presente.

ScheduledExecutorService : questa interfaccia aggiunge la possibilità di eseguire attività in sospeso con un certo ritardo o un certo periodo.

AbstractExecutorService è una classe astratta per la costruzione di un ExecutorService 'a. Al suo interno è presente un'implementazione dei metodi submit , invokeAll , invokeAny . Questa classe eredita ThreadPoolExecutor , ScheduledThreadPoolExecutor e ForkJoinPool .

public static void main(String[] args) {
   ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
   Callable<String> task = () -> {
       System.out.println(Thread.currentThread().getName());
       return Thread.currentThread().getName();
   };
   scheduledExecutorService.schedule(task, 10, TimeUnit.SECONDS);
   scheduledExecutorService.shutdown();
}

ThreadPoolExecutor

Executors è una classe factory per la creazione di ThreadPoolExecutor , ScheduledThreadPoolExecutor . Se devi creare uno di questi pool, questa fabbrica è esattamente ciò di cui hai bisogno. Contiene diversi adattatori Runnable-Callable, PrivilegedAction-Callable, PrivilegedExceptionAction-Callable e altri. Dispone di metodi statici per la creazione di diversi ThreadPool .

ThreadPoolExecutor : implementa le interfacce Executor ed ExecutorService e separa la creazione dell'attività dall'esecuzione dell'attività. Dobbiamo implementare gli oggetti Runnable e inviarli all'esecutore, e ThreadPoolExecutor è responsabile della loro esecuzione, creazione di istanze e lavoro con i thread.

ScheduledThreadPoolExecutor : oltre ai metodi ThreadPoolExecutor , crea un pool di thread in grado di pianificare i comandi da eseguire dopo un determinato ritardo o per l'esecuzione periodica.

ThreadFactoryè un oggetto che crea nuovi thread su richiesta. Dobbiamo passare un'istanza al metodo Executors.newSingleThreadExecutor(ThreadFactory threadFactory) .

ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactory() {
 @Override public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "MyThread");
thread.setPriority(Thread.MAX_PRIORITY);
 return thread; }
 });

RejectedExecutionHandler : consente di definire un gestore per le attività che per qualche motivo non possono essere eseguite tramite ThreadPoolExecutor . Ciò accade quando non ci sono flussi gratuiti o il servizio viene interrotto o arrestato.

Diverse implementazioni standard si trovano nella classe ThreadPoolExecutor :

• CallerRunsPolicy: esegue un'attività sul thread chiamante;
• AbortPolicy: genera un'eccezione;
• DiscardPolicy - ignora l'attività;
• DiscardOldestPolicy: rimuove l'attività non avviata più vecchia dalla coda, quindi tenta di aggiungere nuovamente una nuova attività.

Servizio di completamento

CompletionService è un'interfaccia di servizio con disaccoppiamento tra l'avvio di attività asincrone e l'ottenimento di risultati. Per aggiungere attività, esiste un metododi invioe per ottenere i risultati di attività già completate, vengono utilizzati untakedi pollingnon bloccante.

ExecutorCompletionService è un wrapper su qualsiasi classe che implementa l'interfaccia Executor , ad esempio ThreadPoolExecutor o ForkJoinPool . Viene utilizzato quando è necessario astrarre dal metodo di avvio delle attività e controllarne l'esecuzione.

Se ci sono attività completate, le estraiamo. Se non ci sono compiti, restiamo in attesa finché qualcosa non è completato. Il servizio utilizza una LinkedBlockingQueue al suo interno, ma puoi passare qualsiasi implementazione di BlockingQueue.