1. Gambaran keseluruhan
ExecutorService adalah kerangka yang disediakan oleh JDK yang mempermudah pelaksanaan tugas dalam mod tidak segerak. Secara umum, ExecutorService secara automatik menyediakan kumpulan utas dan API untuk memberikan tugas kepadanya.
2. Instantiating ExecutorService
2.1. Kaedah Kilang Kelas Pelaksana
Kaedah termudah untuk membuat ExecutorService adalah dengan menggunakan salah satu kaedah kilang kelas Executors .
Sebagai contoh, baris kod berikut akan membuat kumpulan utas dengan 10 utas:
ExecutorService executor = Executors.newFixedThreadPool(10);Ini adalah beberapa kaedah kilang lain untuk membuat ExecutorService yang telah ditetapkan yang memenuhi kes penggunaan tertentu. Untuk mencari kaedah terbaik untuk keperluan anda, rujuk dokumentasi rasmi Oracle.
2.2. Langsung Buat Perkhidmatan Pelaksana
Oleh kerana ExecutorService adalah antara muka, contoh pelaksanaannya dapat digunakan. Terdapat beberapa pelaksanaan yang boleh dipilih dalam pakej java.util.concurrent atau anda boleh membuat sendiri.
Sebagai contoh, kelas ThreadPoolExecutor mempunyai beberapa pembina yang boleh digunakan untuk mengkonfigurasi perkhidmatan pelaksana dan kumpulan dalamannya.
ExecutorService executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());Anda mungkin menyedari bahawa kod di atas sangat mirip dengan kod sumber kaedah kilang newSingleThreadExecutor (). Untuk kebanyakan kes, konfigurasi manual terperinci tidak diperlukan.
3. Menyerahkan Tugas ke Pelayan Pelaksana
ExecutorService dapat melaksanakan tugas-tugas Runnable dan Callable . Untuk memastikan perkara mudah dalam artikel ini, dua tugas primitif akan digunakan. Perhatikan bahawa ungkapan lambda digunakan di sini dan bukannya kelas dalaman tanpa nama:
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);
Tugas boleh diberikan kepada ExecutorService menggunakan beberapa kaedah, termasuk execute () , yang diwarisi dari antara muka Executor , dan juga menyerahkan () , invokeAny (), invokeAll ().
Yang melaksanakan () kaedah adalah tidak sah, dan ia tidak memberi apa-apa kemungkinan untuk mendapatkan hasil pelaksanaan tugas atau untuk menyemak status tugas itu (adalah ia berjalan atau dilaksanakan).
executorService.execute(runnableTask);hantar () mengemukakan Dipanggil atau Runnable tugas kepada ExecutorService dan mengembalikan hasil jenis Future .
Future future = executorService.submit(callableTask);invokeAny () memberikan kumpulan tugas kepada ExecutorService, menyebabkan masing-masing dijalankan, dan mengembalikan hasil kejayaan pelaksanaan satu tugas (jika ada pelaksanaan yang berjaya) .
String result = executorService.invokeAny(callableTasks);invokeAll () memberikan kumpulan tugas kepada ExecutorService, menyebabkan masing-masing dijalankan, dan mengembalikan hasil dari semua pelaksanaan tugas dalam bentuk senarai objek jenis Future .
List
futures = executorService.invokeAll(callableTasks);
Sekarang, sebelum melangkah lebih jauh, dua perkara lagi mesti dibincangkan: menutup Perkhidmatan Pelaksana dan menangani jenis pengembalian Masa Depan .
4. Mematikan Perkhidmatan Pelaksana
Secara umum, ExecutorService tidak akan hancur secara automatik apabila tidak ada tugas untuk diproses. Ia akan terus hidup dan menunggu kerja baru dilakukan.
Dalam beberapa kes ini sangat membantu; sebagai contoh, jika aplikasi perlu memproses tugas yang muncul secara tidak teratur atau jumlah tugas ini tidak diketahui pada waktu penyusunan.
Sebaliknya, aplikasi boleh sampai ke penghujungnya, tetapi tidak akan dihentikan kerana ExecutorService yang menunggu akan menyebabkan JVM terus berjalan.
Untuk mematikan ExecutorService dengan betul , kami mempunyai API shutdown () dan shutdownNow () .
Kaedah shutdown () tidak menyebabkan pemusnahan segera ExecutorService. Ini akan menjadikan ExecutorService berhenti menerima tugas baru dan ditutup setelah semua thread berjalan menyelesaikan kerja mereka sekarang.
executorService.shutdown();Kaedah shutdownNow () cuba memusnahkan ExecutorService dengan segera, tetapi ia tidak menjamin bahawa semua thread yang berjalan akan dihentikan pada masa yang sama. Kaedah ini mengembalikan senarai tugas yang sedang menunggu untuk diproses. Terserah kepada pemaju untuk memutuskan apa yang harus dilakukan dengan tugas-tugas ini.
List notExecutedTasks = executorService.shutDownNow();Salah satu cara yang baik untuk mematikan ExecutorService (yang juga disarankan oleh Oracle) adalah menggunakan kedua-dua kaedah ini digabungkan dengan kaedah awaitTermination () . Dengan pendekatan ini, ExecutorService terlebih dahulu akan berhenti mengambil tugas baru, kemudian menunggu hingga jangka waktu yang ditentukan untuk semua tugas diselesaikan. Sekiranya masa itu tamat, pelaksanaan dihentikan serta-merta:
executorService.shutdown(); try { if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) { executorService.shutdownNow(); } } catch (InterruptedException e) { executorService.shutdownNow(); }5. Antara Muka Masa Depan
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.
Kod untuk artikel ini terdapat di repositori GitHub.