Bahasa pemrograman Java bekerja dengan sangat efisien aplikasi yang membutuhkan tugas untuk dijalankan secara bersamaan di thread. Menjadi sulit bagi aplikasi apa pun untuk mengeksekusi sejumlah besar utas secara bersamaan. Jadi untuk mengatasi masalah ini, hadir dengan ExecutorService yang merupakan sub-antarmuka dari . Pada artikel ini, kita akan membahas fungsionalitas ExecutorService di Java. Berikut adalah topik yang dibahas dalam blog ini:
- Apa itu Executor Framework?
- ExecutorService dalam Contoh Java
- Implementasi Java ExecutorService
- Penggunaan ExecutorService
- Runnable vs Callable
- ExecutorService Shutdown
Apa itu Executor Framework?
Cukup lebih mudah untuk membuat dan menjalankan satu atau dua utas secara bersamaan. Tetapi menjadi sulit ketika jumlah utas meningkat menjadi jumlah yang signifikan. Aplikasi multi-utas yang besar akan memiliki ratusan utas yang berjalan secara bersamaan. Oleh karena itu, masuk akal untuk memisahkan pembuatan utas dari manajemen utas dalam aplikasi.
Pelaksana adalah a membantu Anda dalam membuat dan mengelola utas dalam aplikasi. Itu membantu Anda dalam tugas-tugas berikut.
Pembuatan Thread: Ini menyediakan berbagai metode untuk pembuatan thread yang membantu menjalankan aplikasi Anda secara bersamaan.
Manajemen Benang: Ini juga mengatur siklus hidup benang. Anda tidak perlu khawatir jika utas aktif, sibuk atau mati sebelum mengirimkan tugas untuk dieksekusi.
Pengajuan dan Eksekusi Tugas: Kerangka pelaksana menyediakan metode untuk pengajuan tugas di kumpulan utas, Ini juga memberikan kekuatan untuk memutuskan apakah utas akan dieksekusi atau tidak.
ExecutorService dalam Contoh Java
Ini adalah sub-antarmuka dari kerangka pelaksana yang menambahkan fungsionalitas tertentu untuk mengelola siklus hidup thread suatu aplikasi. Ini juga menyediakan metode submit () yang bisa menerima runnable dan callable benda.
Dalam contoh berikut, kami akan membuat ExecutorService dengan satu utas dan kemudian mengirimkan tugas untuk dieksekusi di dalam utas.
impor java.util.concurrent.ExecutorService impor java.util.concurrent.Executors kelas publik Contoh {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('membuat ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('membuat runnable') Runnable runnable = () -> {System.out.println ('di dalam: '+ Thread.currentThread (). GetName ())} System.out.println (' kirimkan tugas yang ditentukan oleh runnable ke executorservice ') executorservice.submit (runnable)}}Keluaran: Inside: main membuat ExecutorService membuat runnable mengirimkan tugas yang ditentukan oleh runnable ke executorservice di dalam: pool-1-thread-1
Di atas menunjukkan bagaimana kita dapat membuat ExecutorService dan menjalankan tugas di dalam eksekutor. Jika tugas dikirim untuk dieksekusi dan thread sedang sibuk menjalankan tugas lain, maka tugas akan menunggu dalam antrean hingga thread bebas untuk menjalankannya.
Ketika Anda menjalankan program di atas, program tidak akan pernah keluar. Anda harus mematikannya secara eksplisit karena layanan eksekutor terus mendengarkan tugas baru.
Implementasi Java ExecutorService
ExecutorService sangat mirip dengan kumpulan utas. Sebenarnya, implementasi ExecutorService di java.util.concurrent paket adalah implementasi threadpool. ExecutorService memiliki implementasi berikut di paket java.util.concurrent:
ThreadPoolExecutor
ThreadPoolExecutor menjalankan tugas yang diberikan menggunakan salah satu utas yang dikumpulkan secara internal.
Membuat threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 panjang keepAliveTime = 5000 ExecutorService threadPoolExecutor = threadPoolExecutor baru (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, baru LinkedBlockingQueue ())
ScheduledThreadPoolExecutor
Java.util.concurrent.ScheduledThreadPoolExecutor adalah ExecutorService yang dapat menjadwalkan tugas untuk dijalankan setelah penundaan atau untuk dieksekusi berulang kali dengan interval waktu tetap di antara setiap eksekusi.
Contoh
ScheduledExecutorService scheduleexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture schedulefuture = scheduleExecutorService.schedule (baru Callable () {public Object call () melempar Exception {System.out.println ('dieksekusi') return 'dipanggil'}}, 5, TimeUnit. DETIK)Penggunaan ExecutorService
Ada beberapa cara berbeda untuk mendelegasikan tugas ke ExecutorService.
jalankan (Runnable)
kirim (Dapat dijalankan)
invokeAny ()
invokeAll ()
Jalankan Runnable
Java ExecutorService mengeksekusi (Runnable) mengambil objek java.lang.Runnable dan menjalankannya secara asinkron.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (Runnable baru () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()Tidak ada cara untuk mendapatkan hasil eksekusi Runnable, untuk itu Anda harus menggunakan Callable.
Kirimkan Runnable
Metode pengiriman Java ExecutorService (Runnable) mengambil implementasi Runnable dan mengembalikan objek di masa mendatang. Objek masa depan dapat digunakan untuk memeriksa apakah Runnable telah selesai dijalankan.
Future future = executorService.submit (new Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // mengembalikan null jika tugas diselesaikan dengan benar.Kirimkan Callable
Metode Java ExecutorService submit (Callable) mirip dengan submit (Runnable) tetapi menggunakan Java Callable, bukan Runnable.
Future future = executorService.submit (new Callable () {public Object call () memunculkan Exception {System.out.println ('Asynchronous callable') return 'Callable Result'}}) System.out.println ('future.get ( ) = 'masa depan.get ())Keluaran: Masa depan yang dapat dipanggil asinkron.get = Hasil yang Dapat Dipanggil
invokeAny ()
Metode invokeAny () mengambil kumpulan objek yang Dapat Dipanggil. Memanggil metode ini tidak mengembalikan masa depan apa pun, tetapi mengembalikan hasil dari salah satu objek Callable.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = HashSet baru () 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 .mematikan()
Ketika Anda menjalankan kode di atas, hasilnya berubah. Mungkin Tugas A, Tugas B, dan seterusnya.
InvokeAll ()
Metode invokeAll () memanggil semua objek Callable yang diteruskan sebagai parameter. Ia mengembalikan objek masa depan yang dapat digunakan untuk mendapatkan hasil dari eksekusi setiap Callable.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = HashSet baru () 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'}}) Daftar futures = executorService.invokeAll (callables) untuk (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
Antarmuka runnable dan callable sangat mirip satu sama lain. Perbedaannya terlihat pada deklarasi file antarmuka. Kedua antarmuka tersebut mewakili tugas yang dapat dijalankan secara bersamaan oleh thread atau ExecutorService.
Deklarasi yang Dapat Dipanggil:
antarmuka publik Dapat dipanggil {public object call () melempar Exception}Deklarasi Runnable:
antarmuka publik Runnable {public void run ()}Perbedaan utama antara keduanya adalah metode call () bisa mengembalikan objek dari pemanggilan metode. Dan metode call () bisa melempar sedangkan metode run () tidak bisa.
perbedaan antara antarmuka dan kelas di java
batalkan tugas
Anda dapat membatalkan tugas yang dikirimkan ke ExecutorService hanya dengan memanggil metode pembatalan di masa mendatang yang dikirimkan saat tugas dikirimkan.
future.cancel ()
ExecutorService Shutdown
Untuk menjaga agar thread tidak berjalan bahkan setelah eksekusi selesai, Anda harus menutup ExecutorService.
mematikan()
Untuk menghentikan utas di dalam ExecutorService, Anda bisa memanggil metode shutdown ().
executorService.shutdown ()
Ini membawa kita ke akhir artikel ini di mana kita telah mempelajari bagaimana kita dapat menggunakan ExecutorService untuk menjalankan tugas di sebuah utas. Saya harap Anda jelas dengan semua yang telah dibagikan dengan Anda dalam tutorial ini.
Jika Anda menemukan artikel tentang 'ExecutorService di Java' ini relevan, lihat perusahaan pembelajaran online tepercaya dengan jaringan lebih dari 250.000 pelajar puas yang tersebar di seluruh dunia.
Kami di sini untuk membantu Anda dengan setiap langkah dalam perjalanan Anda dan menghasilkan kurikulum yang dirancang untuk siswa dan profesional yang ingin menjadi Pengembang Java. Kursus ini dirancang untuk memberi Anda awal yang baik dalam pemrograman Java dan melatih Anda untuk konsep Java inti dan lanjutan bersama dengan berbagai Suka Hibernasi & .
Jika Anda menemukan pertanyaan, silakan ajukan semua pertanyaan Anda di bagian komentar 'ExecutorService di Java' dan tim kami akan dengan senang hati menjawabnya.