Java ExecutorService este interfața care ne permite să executăm sarcini pe fire în mod asincron. Interfața Java ExecutorService este prezentă în pachetul java.util.concurrent. ExecutorService ajută la menținerea unui grup de fire și le atribuie sarcini. De asemenea, oferă posibilitatea de a pune în coadă sarcinile până când există un fir liber disponibil dacă numărul de sarcini este mai mare decât firele disponibile.
Metodele Java ExecutorService
| Metodă | Descriere |
|---|---|
| boolean awaitTermination (timeout lung, unitate TimeUnit) | Această metodă blochează sarcina de a intra în ExecutorService până când toate sarcinile s-au finalizat după cererea de închidere, sau apare timpul de expirare dat sau firul curent este întrerupt, oricare dintre acestea se întâmplă mai întâi. |
| Listă | Această metodă execută lista sarcinilor date și returnează lista de viitor care conține rezultatele tuturor sarcinilor când sunt finalizate. |
| Listă | Această metodă execută lista sarcinilor date și returnează lista de viitor care conține rezultatele tuturor sarcinilor când sunt finalizate sau expiră timpul de expirare, oricare dintre acestea survine primul. |
| T invokeAny(Colecțiesarcini) | Această metodă execută lista sarcinilor date și returnează rezultatul unei sarcini care este finalizată fără a arunca nicio excepție. |
| T invokeAny(Colecțiesarcini, timeout lung, unitate TimeUnit) | Această metodă execută lista sarcinilor date și returnează rezultatul unei sarcini care este finalizată fără a arunca nicio excepție înainte de expirarea timpului. |
| boolean isShutdown() | Această metodă returnează dacă executantul dat este închis sau nu. |
| boolean este terminat() | Această metodă returnează true dacă toate sarcinile au fost executate după oprire. |
| void shutdown() | Această metodă permite finalizarea sarcinilor trimise anterior către ExecutorService și nu permite acceptarea altor sarcini. |
| List shutdownNow() | Această metodă oprește toate sarcinile care se execută în mod activ, oprește execuția sarcinilor aflate în coadă și returnează lista sarcinilor care sunt puse în coadă. |
| Trimitere viitoare (sarcină care poate fi apelată) | Această metodă trimite o sarcină de returnare a valorii pentru execuție și returnează Viitorul, care reprezintă rezultatul în așteptare al sarcinii. |
| Trimitere viitoare (sarcină rulabilă) | Această metodă trimite o sarcină pentru execuție și returnează un viitor reprezentând acea sarcină. Se întoarce nul la finalizarea cu succes. |
| Trimitere viitoare (sarcină rulabilă, rezultat T) | Această metodă trimite o sarcină pentru execuție și returnează un viitor reprezentând acea sarcină. |
Un program simplu al Java ExecutorService
public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(10); executorService.execute(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); executorService.shutdown(); } } Ieșire:
În acest program, creăm un ExecutorService cu zece fire de execuție și îi atribuim o implementare rulabilă anonimă care efectuează o sarcină pentru a tipări „ExecutorService” și după ce sarcina sa se încheie, închidem serviciul executor.
Cum să utilizați Java ExecutorService
Instanțarea ExecutorService
Putem folosi Java ExecutorService pentru a crea un singur thread, un pool de fire sau un pool programat de fire. Clasa Executors oferă metode din fabrică pentru a instanția un ExecutorService după cum urmează:
ExecutorService executorService1 = Executors.newSingleThreadExecutor(); //Creates //a ExecutorService object having a single thread. ExecutorService executorService2 = Executors.newFixedThreadPool(10); // Creates a //ExecutorService object having a pool of 10 threads. ExecutorService executorService3 = Executors.newScheduledThreadPool(10); //Creates a scheduled thread pool executor with 10 threads. In scheduled thread //pool, we can schedule tasks of the threads.
Atribuirea sarcinilor către ExecutorServices
Pentru a atribui o sarcină la ExecutorService, putem folosi următoarele metode:
- execute (sarcină rulabilă)
- trimite (sarcină rulabilă) / trimite (sarcină apelabilă)
- invokeAny(Colecțiesarcini)
- invokeAll(Colecțiesarcini)
Exemplu de atribuire a unei sarcini către ExecutorService folosind metoda execute().
Metoda execute() a Java ExecutorService preia un obiect rulabil și își realizează sarcina asincron. După ce facem apelul la metoda de execuție, apelăm metoda shutdown, care blochează orice altă sarcină în coada de așteptare în executorService.
public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.execute(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); executorService.shutdown(); } } Ieșire:
ExecutorService
Exemplu de atribuire a unei sarcini către ExecutorService folosind submit()
Metoda submit() preia un obiect rulabil și returnează un obiect Future. Acest obiect este folosit mai târziu pentru a verifica starea Runnable dacă s-a încheiat sau nu execuția.
public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); } } Exemplu de atribuire a unei sarcini către ExecutorService folosind metoda invokeAny().
Metoda invokeAny() preia o colecție de obiecte Callablle sau obiecte din clase care implementează Callable. Această metodă returnează viitorul obiect al obiectului apelabil care este executat cu succes mai întâi.
public class ExecutorServiceExample { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Set<callable> callables = new HashSet<callable>(); callables.add(new Callable() { public String call() throws Exception { return 'Task 1'; } }); callables.add(new Callable() { public String call() throws Exception { return 'Task 2'; } }); callables.add(new Callable() { public String call() throws Exception { return 'Task 3'; } }); String result = executorService.invokeAny(callables); System.out.println('result = ' + result); executorService.shutdown(); } } </callable></callable> Ieșire:
result = Task 1
Rezultatul stochează Sarcina 1, deoarece primul obiect apelabil este executat cu succes mai întâi.
str.inlocuire in java
Exemplu de atribuire a unei sarcini către ExecutorService folosind metoda invokeAll().
Metoda invokeAll() preia o colecție de obiecte apelabile având sarcini și returnează o listă de obiecte viitoare care conține rezultatul tuturor sarcinilor.
public class ExecutorServiceExample { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Set<callable> callables = new HashSet<callable>(); callables.add(new Callable() { public String call() throws Exception { return 'Task 1'; } }); callables.add(new Callable() { public String call() throws Exception { return 'Task 2'; } }); callables.add(new Callable() { public String call() throws Exception { return 'Task 3'; } }); java.util.List<future> futures = executorService.invokeAll(callables); for(Future future : futures){ System.out.println('future.get = ' + future.get()); } executorService.shutdown(); } } </future></callable></callable> Ieșire:
future.get = Task 1 future.get = Task 3 future.get = Task 2
Cum să închideți ExecutorService
Odată ce am terminat cu sarcinile noastre date ExecutorService, atunci trebuie să îl închidem, deoarece ExecutorService îndeplinește sarcina pe diferite fire. Dacă nu închidem ExecutorService, firele de execuție vor continua să ruleze, iar JVM-ul nu se va închide.
Procesul de închidere se poate face prin următoarele trei metode:
- metoda shutdown().
- metoda shutdownNow().
- metoda waitTermination().