Limbajul de programare Java funcționează foarte eficient cu aplicații care necesită executarea simultană a sarcinilor într-un thread. Devine dificil pentru orice aplicație să execute simultan un număr mare de fire. Deci, pentru a depăși această problemă, vine cu ExecutorService care este o subinterfață a . În acest articol, vom discuta despre funcționalitatea ExecutorService în Java. Următoarele sunt subiectele tratate în acest blog:
- Ce este Executor Framework?
- ExecutorService în Java Exemplu
- Implementări Java ExecutorService
- Utilizarea ExecutorService
- Runnable vs Callable
- ExecutorService Shutdown
Ce este Executor Framework?
Este destul de ușor să creați și să executați unul sau două fire simultan. Dar devine dificil când numărul de fire crește la un număr semnificativ. Aplicațiile mari cu mai multe fire vor avea sute de fire care rulează simultan. Prin urmare, este complet logic să separați crearea firului de gestionare a firelor într-o aplicație.
Executorul este un vă ajută în crearea și gestionarea firelor într-o aplicație. vă ajută în următoarele sarcini.
Crearea firului: oferă o varietate de metode pentru crearea de fire care ajută la rularea simultană a aplicațiilor.
Gestionarea firului: gestionează, de asemenea, ciclul de viață al firului. Nu trebuie să vă faceți griji dacă firul este activ, ocupat sau mort înainte de a trimite sarcina pentru execuție.
Trimiterea și execuția sarcinilor: cadrul Executor oferă metode pentru trimiterea sarcinilor în grupul de fire, oferă, de asemenea, puterea de a decide dacă firul va fi executat sau nu.
ExecutorService în Java Exemplu
Este o sub-interfață a cadrului de executare care adaugă anumite funcționalități pentru a gestiona ciclul de viață al firului unei aplicații. De asemenea, oferă o metodă submit () care poate accepta atât rulabilită, cât și apelabilă obiecte.
În exemplul următor, vom crea un ExecutorService cu un singur fir și apoi vom trimite sarcina de executat în interiorul firului.
import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class Exemplu {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('creando ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('creando un runnable') Runnable runnable = () -> {System.out.println ('inside: '+ Thread.currentThread (). GetName ())} System.out.println (' trimite sarcina specificată de runnable către executorservice ') executorservice.submit (runnable)}}Ieșire: Inside: main creando ExecutorService creând un runnable trimiteți sarcina specificată de runnable către executorservice din interiorul: pool-1-thread-1
De mai sus arată cum putem crea un ExecutorService și să executăm o sarcină în interiorul executorului. Dacă o sarcină este trimisă pentru executare și firul este ocupat în prezent cu executarea unei alte sarcini, atunci sarcina va aștepta într-o coadă până când firul este liber să-l execute.
Când rulați programul de mai sus, programul nu va ieși niciodată. Va trebui să îl închideți în mod explicit, deoarece serviciul executant continuă să asculte noi sarcini.
Implementări Java ExecutorService
ExecutorService este foarte similar cu un pool de fire. De fapt, implementarea ExecutorService în java.util.concurrent pachet este o implementare threadpool. ExecutorService are următoarele implementări în pachetul java.util.concurrent:
ThreadPoolExecutor
ThreadPoolExecutor execută sarcinile date folosind unul dintre firele sale grupate intern.
Crearea unui threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = new threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue ())
ScheduledThreadPoolExecutor
Java.util.concurrent.ScheduledThreadPoolExecutor este un ExecutorService care poate programa sarcini pentru a rula după o întârziere sau pentru a executa în mod repetat cu un interval de timp fix între fiecare execuție.
Exemplu
ScheduledExecutorService schedulexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture schedulfuture = schedulExecutorService.schedule (new Callable () {public Object call () lansează Exception {System.out.println ('executat') return 'chemat'}}, 5, TimeUnit SECUNDE)Utilizarea ExecutorService
Există câteva moduri diferite de a delega sarcini către un ExecutorService.
executa (Runnable)
trimite (Runnable)
invocaOricare ()
invokeAll ()
Executați Runnable
Executarea Java ExecutorService (Runnable) ia un obiect java.lang.Runnable și îl execută asincron.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (nou Runnable () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()Nu există nicio modalitate de a obține rezultatul executării Runnable, pentru aceasta trebuie să utilizați Callable.
Trimite Runnable
Metoda Java ExecutorService submit (Runnable) ia o implementare Runnable și returnează un obiect viitor. Viitorul obiect poate fi folosit pentru a verifica dacă Runnable a terminat de executat.
Future future = executorService.submit (new Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // returnează nul dacă sarcina este terminată corect.Trimiteți apelabil
Metoda Java ExecutorService submit (Callable) este similară cu submit (Runnable), dar este necesară Java Callable în loc de Runnable.
Viitor viitor = executorService.submit (nou Callable () {apel public Object () aruncă Excepție {System.out.println ('Asynchronous callable') returnează 'Callable Result'}}) System.out.println ('future.get ( ) = 'future.get ())Ieșire: Asynchroous callable future.get = Rezultat apelabil
invocaOricare ()
Metoda invokeAny () ia o colecție de obiecte Callable. Invocarea acestei metode nu returnează niciun viitor, dar returnează rezultatul unuia dintre obiectele apelabile.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = HashSet nou () callables.add (new Callable () {public String call () throws Exception {return'task A '}}) callables.add (new Callable () {public String call () throws Exception {return'task B'} }) callables.add (new Callable () {public String call () throws Exception {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .închide()
Când rulați codul de mai sus, rezultatul se schimbă. Ar putea fi sarcina A, sarcina B și așa mai departe.
InvokeAll ()
Metoda invokeAll () invocă toate obiectele apelabile trecute ca parametri. Returnează obiectele viitoare care pot fi utilizate pentru a obține rezultatele execuției fiecărui apelabil.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = HashSet nou () callables.add (new Callable () {public String call () throws Exception {return 'Task A'}}) callables.add (new Callable () {public String call () throws Exception {return 'Task B'} }) callables.add (new Callable () {public String call () throws Exception {return 'Task C'}}) List futures = executorService.invokeAll (callables) for (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
Interfețele rulabile și apelabile sunt foarte asemănătoare. Diferența este vizibilă în declarația interfețe. Ambele interfețe reprezintă o sarcină care poate fi executată concomitent de un fir sau de ExecutorService.
Declarație apelabilă:
interfață publică Callable {public object call () throws Exception}Declarație Runnable:
interfață publică Runnable {public void run ()}Principala diferență dintre cele două este că metoda call () poate returna un obiect din apelul metodei. Și metoda call () poate arunca un în timp ce metoda run () nu poate.
ce este bucătarul în devops
anulați sarcina
Puteți anula sarcina trimisă la ExecutorService apelând pur și simplu metoda de anulare la viitorul trimis atunci când sarcina este trimisă.
future.cancel ()
ExecutorService Shutdown
Pentru a împiedica executarea firelor chiar și după finalizarea executării, ar trebui să închideți ExecutorService.
închide()
Pentru a termina firele din interiorul unui ExecutorService puteți apela metoda shutdown ().
executorService.shutdown ()
Acest lucru ne duce la sfârșitul acestui articol, unde am aflat cum putem folosi ExecutorService pentru a executa sarcini într-un thread. Sper că ești clar cu tot ce ți-a fost împărtășit în acest tutorial.
Dacă ați găsit relevant acest articol despre „ExecutorService în Java”, consultați o companie de învățare online de încredere, cu o rețea de peste 250.000 de elevi mulțumiți răspândiți pe tot globul.
Suntem aici pentru a vă ajuta cu fiecare pas din călătoria dvs. și pentru a veni cu un curriculum care este conceput pentru studenți și profesioniști care doresc să fie un dezvoltator Java. Cursul este conceput pentru a vă oferi un început important în programarea Java și pentru a vă instrui atât pentru conceptele Java de bază, cât și pentru cele avansate, împreună cu diverse ca Hibernează & .
Dacă întâmpinați orice întrebare, nu ezitați să vă adresați toate întrebările în secțiunea de comentarii din „ExecutorService în Java”, iar echipa noastră va fi bucuroasă să vă răspundă.