Bahasa pengaturcaraan Java berfungsi dengan cekap aplikasi yang memerlukan tugas untuk dilaksanakan secara serentak dalam utas. Menjadi sukar bagi mana-mana aplikasi untuk melaksanakan sebilangan besar utas secara serentak. Jadi untuk mengatasi masalah ini, dilengkapi dengan ExecutorService yang merupakan sub-antara muka dari . Dalam artikel ini, kita akan membincangkan fungsi ExecutorService di Java. Berikut adalah topik yang dibahas dalam blog ini:
- Apakah Rangka Kerja Pelaksana?
- Perkhidmatan Pelaksana di Java Contoh
- Pelaksanaan Perkhidmatan Pelaksana Java
- Penggunaan Perkhidmatan Pelaksana
- Runnable vs Callable
- Penutupan Perkhidmatan Pelaksana
Apakah Rangka Kerja Pelaksana?
Lebih mudah untuk membuat dan melaksanakan satu atau dua utas secara serentak. Tetapi menjadi sukar apabila bilangan utas meningkat menjadi bilangan yang ketara. Aplikasi berbilang benang yang besar akan mempunyai ratusan utas berjalan serentak. Oleh itu, masuk akal untuk memisahkan penciptaan utas dari pengurusan utas dalam aplikasi.
Pelaksana adalah seorang membantu anda dalam membuat dan menguruskan utas dalam aplikasi. The menolong anda dalam tugas-tugas berikut.
Thread Creation: Ini menyediakan pelbagai kaedah untuk membuat utas yang membantu menjalankan aplikasi anda secara serentak.
Pengurusan Thread: Ia juga menguruskan kitar hayat utas. Anda tidak perlu risau jika utas aktif, sibuk atau mati sebelum menyerahkan tugas untuk dilaksanakan.
Penyerahan Tugas Dan Pelaksanaan: Kerangka pelaksana menyediakan kaedah untuk penyerahan tugas di kumpulan utas, Ini juga memberikan kekuatan untuk memutuskan apakah utas akan dijalankan atau tidak.
Perkhidmatan Pelaksana di Java Contoh
Ini adalah sub-antaramuka kerangka pelaksana yang menambahkan fungsi tertentu untuk menguruskan kitar hayat aplikasi. Ini juga menyediakan kaedah submit () yang dapat menerima runnable dan callable benda.
Dalam contoh berikut, kami akan membuat ExecutorService dengan satu utas dan kemudian menyerahkan tugas yang akan dilaksanakan di dalam utas.
import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class Contoh {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( System.out.println ('create ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('create a runnable') Runnable runnable = () -> {System.out.println ('di dalam: '+ Thread.currentThread (). GetName ())} System.out.println (' serahkan tugas yang ditentukan oleh runnable ke pelaksana perkhidmatan ') executorservice.submit (runnable)}}Pengeluaran: Inside: main mencipta ExecutorService membuat runnable menyerahkan tugas yang ditentukan oleh runnable ke executorservice di dalam: pool-1-thread-1
Di atas menunjukkan bagaimana kita dapat membuat ExecutorService dan melaksanakan tugas di dalam pelaksana. Sekiranya tugas diserahkan untuk pelaksanaan dan utas sedang sibuk melaksanakan tugas lain, tugas tersebut akan menunggu dalam barisan sehingga utas bebas untuk melaksanakannya.
Apabila anda menjalankan program di atas, program tersebut tidak akan pernah keluar. Anda perlu mematikannya secara eksplisit kerana perkhidmatan pelaksana terus mendengar tugas baru.
Pelaksanaan Perkhidmatan Pelaksana Java
ExecutorService sangat serupa dengan kumpulan thread. Sebenarnya, pelaksanaan ExecutorService dalam java.util.concurrent pakej adalah pelaksanaan threadpool. ExecutorService mempunyai pelaksanaan berikut dalam pakej java.util.concurrent:
ThreadPoolExecutor
ThreadPoolExecutor melaksanakan tugas yang diberikan menggunakan salah satu utasnya yang dikumpulkan secara dalaman.
Membuat threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = new threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, LinkedBlockingQueue baru ())
BerjadualThreadPoolExecutor
The java.util.concurrent.SchedchedThreadPoolExecutor adalah ExecutorService yang dapat menjadualkan tugas untuk dijalankan setelah penundaan atau untuk melaksanakan berulang kali dengan selang waktu yang tetap di antara setiap pelaksanaan.
Contohnya
SchedchedExecutorService dijadualkanexecutorservice = Executors.newSchedchedThreadPool (5) SchedchedFuture schedfuture = schedExecutorService.schedule (Callable baru () {public Object call () membuang Exception {System.out.println ('dieksekusi') kembali 'dipanggil'}}, 5, TimeUnit. SEKIAN)Penggunaan Perkhidmatan Pelaksana
Terdapat beberapa cara yang berbeza untuk menyerahkan tugas ke ExecutorService.
laksanakan (Runnable)
hantar (Dijalankan)
memanggil mana-mana ()
memanggilSemua ()
Jalankan Runnable
Java ExecutorService execute (Runnable) mengambil objek java.lang.Runnable dan melaksanakannya secara tidak segerak.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('asynchronous task')}}}) executorService.shutdown ()Tidak ada cara untuk mendapatkan hasil Runnable yang dijalankan, untuk itu anda harus menggunakan Callable.
Hantar Runnable
Kaedah Java ExecutorService submit (Runnable) memerlukan pelaksanaan Runnable dan mengembalikan objek masa depan. Objek masa depan dapat digunakan untuk memeriksa apakah Runnable selesai dijalankan.
Masa depan masa depan = executorService.submit (Runnable baru () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // mengembalikan nol jika tugas selesai dengan betul.Hantar Boleh Dipanggil
Kaedah Java ExecutorService submit (Callable) mirip dengan submit (Runnable) tetapi memerlukan Java Callable dan bukan Runnable.
Masa depan masa depan = executorService.submit (Callable baru () {panggilan Objek awam () membuang Pengecualian {System.out.println ('Asynchronous callable') return 'Callable Result'}}) System.out.println ('future.get ( ) = 'masa depan.get ())Pengeluaran: Asynchroous callable future.get = Keputusan Boleh Dipanggil
memanggil mana-mana ()
Kaedah invokeAny () mengambil koleksi objek yang Boleh Dipanggil. Memohon kaedah ini tidak mengembalikan masa depan, tetapi mengembalikan hasil dari salah satu objek yang Boleh Dipanggil.
ExecutorService executorService = Set Pelaksana.newSingleThreadExecutor ()callables = HashSet baru () callables.add (Callable baru () {public String call () membuang Exception {return'task A '}}) callables.add (new Callable () {public String call () membuang Pengecualian {return'task B'} }) callables.add (Callable baru () {public String call () membuang Pengecualian {return'task C '}}) Hasil rentetan = executorService.invokeAny (callables) System.out.println (' result = '+ result) exorService .menutup()
Apabila anda menjalankan kod di atas, hasilnya akan berubah. Mungkin Task A, Task B dan sebagainya.
Memohon Semua ()
Kaedah invokeAll () memanggil semua objek yang boleh dipanggil yang dilewatkan sebagai parameter. Ia mengembalikan objek masa depan yang dapat digunakan untuk mendapatkan hasil pelaksanaan setiap Callable.
ExecutorService executorService = Set Pelaksana.newSingleThreadExecutor ()callables = HashSet baru () callables.add (Callable baru () {public String call () membuang Exception {return 'Task A'}}) callables.add (new Callable () {public String call () membuang Pengecualian {return 'Task B'} }) Callables.add (Callable baru () {public String call () membuang senarai Pengecualian {return 'Task C'}}}) futures = executorService.invokeAll (callables) untuk (Masa depan masa depan: niaga hadapan) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
Antaramuka yang boleh dijalankan dan boleh dipanggil sangat serupa antara satu sama lain. Perbezaannya dapat dilihat dalam pengisytiharan antara muka. Kedua-dua antara muka tersebut mewakili tugas yang dapat dilaksanakan secara serentak oleh utas atau ExecutorService.
Pengisytiharan Boleh Dipanggil:
antara muka awam Boleh dipanggil {panggilan objek awam () melontarkan Pengecualian}Pengisytiharan yang Boleh Dijalankan:
antara muka awam Dijalankan {public void run ()}Perbezaan utama antara keduanya adalah bahawa kaedah panggilan () dapat mengembalikan objek dari kaedah panggilan. Dan kaedah panggilan () dapat membuang sementara kaedah run () tidak boleh.
java bagaimana membuat susunan objek
membatalkan tugas
Anda boleh membatalkan tugas yang diserahkan kepada ExecutorService dengan hanya memanggil kaedah batal pada masa depan yang diserahkan ketika tugas diserahkan.
masa depan.cancel ()
Penutupan Perkhidmatan Pelaksana
Untuk memastikan utas tidak berjalan walaupun pelaksanaannya selesai, anda harus mematikan ExecutorService.
menutup()
Untuk menamatkan utas di dalam ExecutorService, anda boleh memanggil kaedah shutdown ().
pelaksanaService.shutdown ()
Ini membawa kita ke akhir artikel ini di mana kita telah belajar bagaimana kita dapat menggunakan ExecutorService untuk melaksanakan tugas dalam satu utas. Saya harap anda jelas dengan semua yang telah dikongsi dengan anda dalam tutorial ini.
Jika anda mendapati artikel ini mengenai 'ExecutorService in Java' relevan, lihat syarikat pembelajaran dalam talian yang dipercayai dengan rangkaian lebih daripada 250,000 pelajar yang berpuas hati tersebar di seluruh dunia.
Kami di sini untuk membantu anda dalam setiap langkah dalam perjalanan anda dan membuat kurikulum yang dirancang untuk pelajar dan profesional yang ingin menjadi Pembangun Java. Kursus ini dirancang untuk memberi Anda awal dalam pengaturcaraan Java dan melatih anda untuk konsep Java teras dan maju bersama dengan pelbagai suka Hibernate & .
Sekiranya anda menjumpai sebarang pertanyaan, jangan ragu untuk mengajukan semua pertanyaan anda di ruangan komen 'ExecutorService in Java' dan pasukan kami dengan senang hati akan menjawabnya.