Servicii de executori

Executor testamentar

Executor este interfața de bază pentru clase care implementează lansarea sarcinilor Runnable . Aceasta oferă asistență pentru adăugarea unei sarcini și cum să o porniți.

ExecutorService este o interfață care extinde proprietățile Executor și care descrie un serviciu pentru rularea sarcinilor Runnable sau Callable . Metodele de trimitere acceptă o sarcină sub forma unui Callable sau Runnable ca intrare , iar un Future este folosit ca valoare de returnare, prin care puteți obține rezultatul.

Metoda invokeAll este responsabilă pentru executarea sarcinilor, returnând o listă de sarcini cu starea și rezultatele lor de finalizare.

Metoda invokeAny este responsabilă pentru executarea sarcinilor, returnând rezultatul unei sarcini finalizate cu succes (adică fără a arunca o excepție), dacă există.

ScheduledExecutorService - această interfață adaugă capacitatea de a rula sarcini în așteptare cu o anumită întârziere sau o anumită perioadă.

AbstractExecutorService este o clasă abstractă pentru construirea unui ExecutorService 'a. În interior există o implementare a metodelor submit , invokeAll , invokeAny . Această clasă moștenește ThreadPoolExecutor , ScheduledThreadPoolExecutor și 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 este o clasă din fabrică pentru crearea ThreadPoolExecutor , ScheduledThreadPoolExecutor . Dacă trebuie să creați una dintre aceste piscine, atunci această fabrică este exact ceea ce aveți nevoie. Conține diferite adaptoare Runnable-Callable, PrivilegedAction-Callable, PrivilegedExceptionAction-Callable și altele. Are metode statice pentru a crea diferite ThreadPool .

ThreadPoolExecutor - Implementează interfețele Executor și ExecutorService și separă crearea sarcinilor de execuția sarcinii. Trebuie să implementăm obiecte Runnable și să le trimitem executorului, iar ThreadPoolExecutor este responsabil pentru execuția, instanțierea și lucrul cu fire de execuție.

ScheduledThreadPoolExecutor - În plus față de metodele ThreadPoolExecutor , creează un grup de fire de execuție care pot programa comenzi pentru a fi executate după o anumită întârziere sau pentru execuție periodică.

ThreadFactoryeste un obiect care creează fire noi la cerere. Trebuie să transmitem o instanță metodei 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 - vă permite să definiți un handler pentru sarcini care din anumite motive nu pot fi executate prin ThreadPoolExecutor . Acest lucru se întâmplă atunci când nu există fluxuri gratuite sau serviciul este oprit sau oprit.

Mai multe implementări standard se găsesc în clasa ThreadPoolExecutor :

• CallerRunsPolicy - rulează o sarcină pe firul apelant;
• AbortPolicy - aruncă o excepție;
• DiscardPolicy - ignoră sarcina;
• DiscardOldestPolicy - Îndepărtează cea mai veche sarcină nepornită din coadă, apoi încearcă să adauge din nou o sarcină nouă.

Serviciul de finalizare

CompletionService este o interfață de serviciu cu decuplarea lansării sarcinilor asincrone și obținerea de rezultate. Pentru a adăuga sarcini, există o metodăde trimitere, iar pentru a obține rezultatele sarcinilor deja finalizate, se utilizează ode preluarede sondarefără blocare.

ExecutorCompletionService este un wrapper peste orice clasă care implementează interfața Executor , cum ar fi ThreadPoolExecutor sau ForkJoinPool . Este folosit atunci când este necesar să se abstragă de la metoda de lansare a sarcinilor și de control al execuției acestora.

Dacă există sarcini finalizate, atunci le scoatem. Dacă nu există sarcini, atunci amânăm preluarea până când ceva este finalizat. Serviciul folosește un LinkedBlockingQueue la bază, dar puteți trece în orice implementare BlockingQueue.