Un ghid pentru Java ExecutorService

1. Prezentare generală

ExecutorService este un cadru furnizat de JDK care simplifică executarea sarcinilor în mod asincron. În general vorbind, ExecutorService oferă automat un grup de fire și API pentru atribuirea sarcinilor acestuia.

2. Instantierea ExecutorService

2.1. Metode de fabrică ale clasei Executori

Cel mai simplu mod de a crea ExecutorService este să utilizați una dintre metodele din fabrică din clasa Executori .

De exemplu, următoarea linie de cod va crea un pool de fire cu 10 fire:

ExecutorService executor = Executors.newFixedThreadPool(10);

Există mai multe alte metode din fabrică pentru a crea ExecutorService predefinit care îndeplinește cazuri de utilizare specifice. Pentru a găsi cea mai bună metodă pentru nevoile dvs., consultați documentația oficială Oracle.

2.2. Creați direct un ExecutorService

Deoarece ExecutorService este o interfață, poate fi utilizată o instanță a oricărei implementări. Există mai multe implementări din care să alegeți în pachetul java.util.concurrent sau vă puteți crea propriul.

De exemplu, clasa ThreadPoolExecutor are câțiva constructori care pot fi utilizați pentru a configura un serviciu executor și grupul său intern.

ExecutorService executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());

Este posibil să observați că codul de mai sus este foarte similar cu codul sursă al metodei din fabrică newSingleThreadExecutor (). În majoritatea cazurilor, nu este necesară o configurare manuală detaliată.

3. Atribuirea de sarcini ExecutorService

ExecutorService poate executa sarcini Runable și Callable . Pentru a simplifica lucrurile în acest articol, vor fi utilizate două sarcini primitive. Observați că expresiile lambda sunt folosite aici în locul claselor interioare anonime:

Runnable runnableTask = () -> { try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } }; Callable callableTask = () -> { TimeUnit.MILLISECONDS.sleep(300); return "Task's execution"; }; List
    
      callableTasks = new ArrayList(); callableTasks.add(callableTask); callableTasks.add(callableTask); callableTasks.add(callableTask);
    

Sarcinile pot fi atribuite ExecutorService utilizând mai multe metode, inclusiv execute () , care este moștenit din interfața Executor și, de asemenea, submit () , invokeAny (), invokeAll ().

Metoda execute () este nulă și nu oferă nicio posibilitate de a obține rezultatul executării sarcinii sau de a verifica starea sarcinii (se execută sau se execută).

executorService.execute(runnableTask);

submit () trimite o activitate Callable sau Runnable către un ExecutorService și returnează un rezultat de tip Future .

Future future = executorService.submit(callableTask);

invokeAny () atribuie o colecție de sarcini unui ExecutorService, determinând executarea fiecăruia și returnează rezultatul executării cu succes a unei sarcini (dacă a existat o execuție reușită) .

String result = executorService.invokeAny(callableTasks);

invokeAll () atribuie o colecție de sarcini unui ExecutorService, determinând executarea fiecăruia și returnează rezultatul tuturor execuțiilor de sarcini sub forma unei liste de obiecte de tip Future .

List
    
      futures = executorService.invokeAll(callableTasks);
    

Acum, înainte de a merge mai departe, trebuie discutate încă două lucruri: închiderea unui Serviciu Executor și tratarea tipurilor de returnare viitoare .

4. Oprirea unui ExecutorService

În general, ExecutorService nu va fi distrus automat atunci când nu există nicio sarcină de procesat. Va rămâne în viață și va aștepta o nouă lucrare de făcut.

În unele cazuri, acest lucru este foarte util; de exemplu, dacă o aplicație trebuie să proceseze sarcini care apar în mod neregulat sau cantitatea acestor sarcini nu este cunoscută la momentul compilării.

On the other hand, an app could reach its end, but it will not be stopped because a waiting ExecutorService will cause the JVM to keep running.

To properly shut down an ExecutorService, we have the shutdown() and shutdownNow() APIs.

The shutdown()method doesn't cause immediate destruction of the ExecutorService. It will make the ExecutorService stop accepting new tasks and shut down after all running threads finish their current work.

executorService.shutdown();

Metoda shutdownNow () încearcă să distrugă ExecutorService imediat, dar nu garantează că toate firele de rulare vor fi oprite în același timp. Această metodă returnează o listă de sarcini care așteaptă să fie procesate. Depinde de dezvoltator să decidă ce să facă cu aceste sarcini.

List notExecutedTasks = executorService.shutDownNow();

O modalitate bună de a închide ExecutorService (care este recomandat și de Oracle) este utilizarea ambelor metode combinate cu metoda awaitTermination () . Cu această abordare, ExecutorService va opri mai întâi preluarea de noi sarcini, apoi va aștepta până la o perioadă de timp specificată pentru toate sarcinile care urmează să fie finalizate. Dacă timpul expiră, execuția este oprită imediat:

executorService.shutdown(); try { if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) { executorService.shutdownNow(); } } catch (InterruptedException e) { executorService.shutdownNow(); }

5. Interfața Viitorului

The submit() and invokeAll() methods return an object or a collection of objects of type Future, which allows us to get the result of a task's execution or to check the task's status (is it running or executed).

The Future interface provides a special blocking method get() which returns an actual result of the Callable task's execution or null in the case of Runnable task. Calling the get() method while the task is still running will cause execution to block until the task is properly executed and the result is available.

Future future = executorService.submit(callableTask); String result = null; try { result = future.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); }

With very long blocking caused by the get() method, an application's performance can degrade. If the resulting data is not crucial, it is possible to avoid such a problem by using timeouts:

String result = future.get(200, TimeUnit.MILLISECONDS);

If the execution period is longer than specified (in this case 200 milliseconds), a TimeoutException will be thrown.

The isDone() method can be used to check if the assigned task is already processed or not.

The Future interface also provides for the cancellation of task execution with the cancel() method, and to check the cancellation with isCancelled() method:

boolean canceled = future.cancel(true); boolean isCancelled = future.isCancelled();

6. The ScheduledExecutorService Interface

The ScheduledExecutorService runs tasks after some predefined delay and/or periodically. Once again, the best way to instantiate a ScheduledExecutorService is to use the factory methods of the Executors class.

For this section, a ScheduledExecutorService with one thread will be used:

ScheduledExecutorService executorService = Executors .newSingleThreadScheduledExecutor();

To schedule a single task's execution after a fixed delay, us the scheduled() method of the ScheduledExecutorService. There are two scheduled() methods that allow you to execute Runnable or Callable tasks:

Future resultFuture = executorService.schedule(callableTask, 1, TimeUnit.SECONDS);

The scheduleAtFixedRate() method lets execute a task periodically after a fixed delay. The code above delays for one second before executing callableTask.

The following block of code will execute a task after an initial delay of 100 milliseconds, and after that, it will execute the same task every 450 milliseconds. If the processor needs more time to execute an assigned task than the period parameter of the scheduleAtFixedRate() method, the ScheduledExecutorService will wait until the current task is completed before starting the next:

Future resultFuture = service .scheduleAtFixedRate(runnableTask, 100, 450, TimeUnit.MILLISECONDS);

If it is necessary to have a fixed length delay between iterations of the task, scheduleWithFixedDelay() should be used. For example, the following code will guarantee a 150-millisecond pause between the end of the current execution and the start of another one.

service.scheduleWithFixedDelay(task, 100, 150, TimeUnit.MILLISECONDS);

According to the scheduleAtFixedRate() and scheduleWithFixedDelay() method contracts, period execution of the task will end at the termination of the ExecutorService or if an exception is thrown during task execution.

7. ExecutorService vs. Fork/Join

After the release of Java 7, many developers decided that the ExecutorService framework should be replaced by the fork/join framework. This is not always the right decision, however. Despite the simplicity of usage and the frequent performance gains associated with fork/join, there is also a reduction in the amount of developer control over concurrent execution.

ExecutorService gives the developer the ability to control the number of generated threads and the granularity of tasks which should be executed by separate threads. The best use case for ExecutorService is the processing of independent tasks, such as transactions or requests according to the scheme “one thread for one task.”

In contrast, according to Oracle's documentation, fork/join was designed to speed up work which can be broken into smaller pieces recursively.

8. Conclusion

Even despite the relative simplicity of ExecutorService, there are a few common pitfalls. Let's summarize them:

Keeping an unused ExecutorService alive: There is a detailed explanation in section 4 of this article about how to shut down an ExecutorService;

Wrong thread-pool capacity while using fixed length thread-pool: It is very important to determine how many threads the application will need to execute tasks efficiently. A thread-pool that is too large will cause unnecessary overhead just to create threads which mostly will be in the waiting mode. Too few can make an application seem unresponsive because of long waiting periods for tasks in the queue;

Calling a Future‘s get() method after task cancellation: An attempt to get the result of an already canceled task will trigger a CancellationException.

Unexpectedly-long blocking with Future‘s get() method: Timeouts should be used to avoid unexpected waits.

Codul pentru acest articol este disponibil într-un depozit GitHub.