Executor and ExecutorService API ialah alat penting untuk mengurus dan mengawal pelaksanaan thread. Ia adalah sebahagian daripada pakej java.util.concurrent. Mereka memudahkan proses pengaturcaraan serentak dengan mengabstraksikan kerumitan penciptaan benang, pengurusan dan penyegerakan.

Executors ialah kelas utiliti daripada pakej java.util.concurrent menyediakan kaedah kilang untuk mencipta dan mengurus jenis contoh ExecutorService yang berbeza. Ia memudahkan proses mencipta kumpulan benang dan membolehkan kami membuat dan mengurus kejadian pelaksana dengan mudah dengan konfigurasi yang berbeza.

API Pelaksana Ia ialah antara muka yang tersedia sejak Java 1.5. Ia menyediakan kaedah laksana (Arahan boleh dijalankan). Ini adalah antara muka asas dan ExecutorService memanjangkan antara muka ini. Perintah yang diberikan akan dilaksanakan pada masa hadapan oleh urutan atau utas baharu daripada kumpulan utas atau utas yang sama dan tidak mengembalikan batal.

ExecutorService API Ia ialah antara muka yang tersedia sejak Java 1.5. Ia menyediakan pelbagai kaedah untuk mengawal pelaksanaan tugas dalam pengaturcaraan serentak. Ia menyokong kedua-dua tugas Runnable dan Callable. Ia mengembalikan Masa Depan untuk status tugas. Di bawah adalah kaedah yang paling kerap digunakan.

• submit() menerima tugasan Boleh Panggil atau Boleh Jalankan dan mengembalikan hasil jenis Masa Depan.

• invokeAny() menerima koleksi tugasan untuk dijalankan dan mengembalikan hasil pelaksanaan yang berjaya bagi mana-mana satu tugas.

• invokeAll() menerima koleksi tugasan untuk dijalankan dan mengembalikan hasil semua tugasan dalam bentuk senarai jenis objek Masa Depan.

• shutdown() ia tidak menghentikan perkhidmatan pelaksana serta-merta tetapi tidak menerima tugas baharu. Setelah semua tugas yang sedang dijalankan selesai, ia mematikan perkhidmatan pelaksana.

• shutdownNow() ia cuba menghentikan perkhidmatan pelaksana serta-merta, tetapi ia tidak menjamin bahawa semua tugas yang dijalankan akan dihentikan pada masa yang sama.

• menunggu Penamatan(masa tamat masa yang lama, unit TimeUnit) menyekat/menunggu sehingga semua tugasan selesai atau tamat masa berlaku atau urutan semasa terganggu, yang mana berlaku dahulu. Benang semasa akan disekat.

Jenis Perkhidmatan Pelaksana

• FixedThreadPool Ia meletakkan kumpulan benang saiz tetap dengan bilangan benang yang ditetapkan. Tugasan yang diserahkan dilaksanakan serentak. Jika tiada tugasan, benang akan terbiar sehingga tugasan tiba. Jika urutan sibuk, tugasan akan ditambah baris gilir.

ExecutorService fixedThreadPool = Executors.newScheduledThreadPool(5);
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown();

• CachedThreadPool Mencipta kumpulan utas dan melaraskan secara automatik bilangan utas yang diperlukan dalam kumpulan berdasarkan beban kerja. Jika benang melahu, selama lebih daripada 60 saat, akan ditamatkan. Ini berfungsi dengan baik untuk beban dinamik. Memandangkan benang akan dimatikan selepas tamat masa terbiar, sumber digunakan dengan lebih baik di sini.

ExecutorService fixedThreadPool = Executors.newCachedThreadPool();
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown();

• SingleThreadExecutor Mencipta utas tunggal dan tugasan dilaksanakan secara berurutan. Tiada pemprosesan selari di sini.

ExecutorService fixedThreadPool = Executors.newSingleThreadExecutor();
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown()

• ScheduledThreadPool/ScheduledExecutor Ia mencipta kumpulan benang atau trhead yang akan mempunyai keupayaan untuk menjalankan tugas pada selang masa yang tetap atau dijalankan selepas kelewatan tertentu.

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); // Single-threaded scheduler
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5); // Multi-threaded scheduler

scheduler.schedule(task, 10, TimeUnit.SECONDS); // Schedule task to run after 10 seconds.

scheduler.scheduleAtFixedRate(task, 5, 10, TimeUnit.SECONDS);
    //It schedules a task to run every 10 seconds with an initial delay of 5 seconds.
scheduler.scheduleWithFixedDelay(task, 5, 10, TimeUnit.SECONDS);
   //It schedules a task to run with a fixed delay of 10 seconds between the end of one execution and the start of the next, with an initial delay of 5 seconds.
scheduler.schedule(() -> scheduler.shutdown(), 20, TimeUnit.SECONDS);
   //It schedules a shutdown of the scheduler after 20 seconds to stop the example.

Menyerahkan Tugasan kepada ExecutorService
Tugasan boleh diserahkan kepada ExecutorService menggunakan kaedah execute() dan submit(). Kaedah execute() digunakan untuk tugasan Runnable, manakala submit() boleh mengendalikan kedua-dua tugas Runnable dan Callable."

 executor.execute(new RunnableTask()); //fire-and-forgot
 executor.submit(new CallableTask()); //returns the status of task

Mematikan ExecutorService
Adalah penting untuk menutup ExecutorService untuk mengeluarkan sumber. Anda boleh melakukan ini menggunakan kaedah shutdown() dan shutdownNow().

executor.shutdown(); // Initiates an orderly shutdown"
executor.shutdownNow(); // Attempts to stop all actively executing tasks.
executor.awaitTermination(long timeout, TimeUnit unit); //blocks the thread until all tasks are completed or timeout occurs or current thread is interrupted, whichever happens first. Returns `true `is tasks completed, otherwise `false`.

Pendekatan yang disyorkan untuk menutup

executor.shutdown();
try {
    // Wait for tasks to complete or timeout
    if (!executor.awaitTermination(120, TimeUnit.SECONDS)) {
        // If the timeout occurs, force shutdown
        executor.shutdownNow();      
    }
} catch (InterruptedException ex) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

Mengenai Runnable

• Runnable ialah antara muka dan mewakili tugasan yang boleh dijalankan mengikut urutan.
• Kami boleh menjalankan tugasan Boleh Dijalankan dengan menggunakan perkhidmatan Threads atau Executor.
• Runnable mempunyai kaedah run() dan tidak mengembalikan sebarang data.
• Kami tidak boleh membuang pengecualian yang ditandakan.

Mengenai Boleh Dipanggil

• Ia diperkenalkan dalam 1.5
• Ia mempunyai kaedah panggilan() dan mengembalikan jenis V.
• Ia mengandungi lontaran makna Pengecualian, kita boleh membuang pengecualian yang ditanda.

Mengenai Masa Depan

• Ia mewakili hasil masa hadapan bagi sebarang tugasan.
• Hasilnya akhirnya akan muncul pada masa hadapan selepas pemprosesan permintaan selesai.
• boolean isDone() Mengembalikan status pemprosesan permintaan. Betul jika dilengkapkan sebaliknya salah.
• boolean cancel(boolean mayInterruptIfRunning) Membatalkan tugasan yang diserahkan. jika kita lulus mayInterruptIfRunning sebagai palsu, maka ia tidak akan membatalkan tugas yang telah dimulakan.
• boolean isCancelled() mengembalikan tugas dibatalkan atau tidak.
• V get() mengembalikan hasil tugasan. Sekat urutan jika tugasan tidak selesai.
• V get(masa tamat masa yang lama, unit TimeUnit) Menunggu jika perlu untuk paling lama masa tertentu untuk pengiraan selesai, dan kemudian mendapatkan semula keputusannya. TimeoutException akan dibuang selepas masa yang ditetapkan jika pengiraan tidak selesai.

Selamat Mengekod dan Belajar !!!

Sila tinggalkan ulasan jika anda mempunyai sebarang soalan.

Atas ialah kandungan terperinci Gambaran Keseluruhan Perkhidmatan Pelaksana di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!