Menguasai Penutupan Perkhidmatan Pelaksana: Penjejakan Penamatan ThreadPool

Katakan anda mahu melaksanakan beberapa tugasan. Memandangkan melaksanakannya melalui satu urutan mungkin mengambil masa yang agak lama untuk mendapatkan hasilnya, anda memutuskan untuk menggunakan ExecutorService yang sentiasa boleh dipercayai untuk memprosesnya melalui berbilang urutan.

Ini contoh:

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        int temp = i;
        executorService.submit(() -> {
            task(temp);
        });
    }
    executorService.shutdown();
    System.out.println("ExecutorService is shutdown");
}

private static void task(int temp) {
    try {
        TimeUnit.SECONDS.sleep(1L);
        System.out.println("Task " + temp + " completed");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

Sudah tentu, seperti biasa, tiada contoh Benang yang lengkap tanpa menggunakan "tidur" sebagai arketip pelaksanaan tugas.

Ia mengeluarkan,

ExecutorService is shutdown
Task 1 completed
Task 2 completed
Task 0 completed
Task 4 completed
Task 3 completed

Sekarang bayangkan terdapat baris gilir tugasan yang tidak berkesudahan, jumlahnya yang anda tidak tahu. Mungkin ia ditentukan oleh bilangan entri dalam pangkalan data yang ditambah secara dinamik.

Sebagai contoh, bank, di mana ia perlu memproses beberapa transaksi sepanjang hari. Masa tamat urus niaga ialah pukul 5 petang, selepas itu ia tidak akan menerima sebarang tugas tambahan.

Walau bagaimanapun, anda tahu bahawa bilangan tugasan akan terhad dan akan tamat pada satu ketika.

Bagaimana anda tahu titik masa apabila semua tugasan telah selesai?

Jika anda melihat coretan kod di atas, ExecutorService.shutdown() membolehkan utas utama untuk keluar serta-merta, tetapi utas latar belakang masih memproses tugasan yang diterima sehingga selesai. Adakah terdapat cara untuk anda mendapat pemberitahuan tentang penyiapan?

Beberapa penyelesaian terlintas di fikiran:

1. Gunakan CountDownLatch untuk mengira tugasan - tetapi memandangkan anda tidak tahu bilangan tugasan, adalah tidak praktikal untuk menggunakannya.
2. Gunakan ExecutorService.awaitTermination(). Walau bagaimanapun, masa di sini masih tidak dapat ditentukan. Anda boleh menggunakan ExecutorService.awaitTermination (Long.MAX_VALUE, TimeUnit.DAYS) atau sesuatu yang serupa. Tetapi itu sekali lagi panggilan menyekat.

Adakah terdapat cara yang lebih baik untuk menyelesaikan masalah ini?

Java menyediakan cara yang lebih baik dan agak tidak diketahui untuk mengatasinya. "Helah" di sini adalah untuk mengetahui bahawa Executors.newFixedThreadPool pada asasnya ialah ThreadPoolExecutor dengan nilai yang telah ditetapkan. Mari kita semak pelaksanaan Executors.newFixedThreadPool.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Saya sangat mengesyorkan untuk membaca dokumen untuk ThreadPoolExecutor di sini. ExecutorService ialah pembalut yang mudah untuk ThreadPoolExecutor.

... pengaturcara digesa menggunakan kaedah kilang Executors yang lebih mudah Executors.newCachedThreadPool() (kolam benang tidak terhad, dengan penebus guna benang automatik), Executors.newFixedThreadPool(int) (kolam benang saiz tetap) dan Executors.newSingleThreadExecutor(hreadExecutor). ) (benang latar belakang tunggal), yang prakonfigurasikan tetapan untuk penggunaan yang paling biasa senario.

Bahagian yang akan membantu kami menyelesaikan masalah ialah:

Kaedah cangkuk

Kelas ini menyediakan kaedah yang boleh ditindih dilindungi sebelumExecute(Thread, Runnable) dan afterExecute(Runnable, Throwable) yang dipanggil sebelum dan selepas pelaksanaan setiap tugas. Ini boleh digunakan untuk memanipulasi persekitaran pelaksanaan; contohnya, memulakan semula ThreadLocals, mengumpulkan statistik atau menambah entri log. Selain itu, kaedah terminated() boleh ditindih untuk melaksanakan sebarang pemprosesan khas yang perlu dilakukan sebaik sahaja Pelaksana telah ditamatkan sepenuhnya.

Kami boleh menggunakan kaedah yang ditamatkan untuk memberitahu kami tentang perkara yang sama! Tetapi bagaimana kita menggunakannya?

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        int temp = i;
        executorService.submit(() -> {
            task(temp);
        });
    }
    executorService.shutdown();
    System.out.println("ExecutorService is shutdown");
}

private static void task(int temp) {
    try {
        TimeUnit.SECONDS.sleep(1L);
        System.out.println("Task " + temp + " completed");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

Jika anda tidak memilih kelas Anonymous (seperti saya), anda sentiasa boleh melanjutkan ThreadPoolExecutor sendiri untuk mencipta kelas tersuai.

ExecutorService is shutdown
Task 1 completed
Task 2 completed
Task 0 completed
Task 4 completed
Task 3 completed

Berikut ialah output untuk mengesahkan sama ada ia berfungsi mengikut jangkaan kami.

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Apakah beberapa coretan lain yang agak tidak diketahui yang anda gunakan? Beritahu saya dalam ulasan!

Atas ialah kandungan terperinci Menguasai Penutupan Perkhidmatan Pelaksana: Penjejakan Penamatan ThreadPool. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!