Cara menggunakan kumpulan benang untuk melaksanakan pemberitahuan penyelesaian tugas dan panggil balik dalam Java 7

Cara menggunakan kumpulan benang untuk melaksanakan pemberitahuan penyelesaian tugas dan panggil balik dalam Java 7

Dalam pembangunan Java, kumpulan benang ialah mekanisme pemprosesan berbilang benang yang penting Ia boleh mengurus dan menggunakan semula benang, meningkatkan kecekapan dan prestasi program dengan berkesan. Selain dapat melaksanakan tugas secara serentak, kumpulan benang juga boleh melaksanakan pemberitahuan penyelesaian tugas dan fungsi panggil balik, memberikan kami lebih fleksibiliti dan kawalan.

Faedah menggunakan kumpulan benang adalah jelas Ia boleh mengehadkan bilangan benang, menggunakan semula benang, dan mengurangkan overhed penciptaan dan pemusnahan benang. Setiap utas dalam kumpulan utas boleh mendapatkan tugas daripada baris gilir tugas yang dikongsi dan melaksanakannya Apabila pelaksanaan tugas selesai, utas akan kembali secara automatik ke kumpulan utas dan menunggu pelaksanaan tugas seterusnya.

Dalam Java 7, pemberitahuan penyelesaian tugas dan panggil balik boleh dilaksanakan melalui antara muka ExecutorService. Antara muka ini mentakrifkan kaedah submit(), yang boleh menerima contoh Boleh Panggil atau Boleh Dijalankan sebagai parameter dan mengembalikan objek Masa Depan. Masa hadapan ialah antara muka yang mewakili hasil operasi tak segerak. Dengan memanggil kaedah get() Masa Depan, anda boleh menyekat pelaksanaan tugas dan mendapatkan hasilnya.

Di bawah ini kami menggunakan contoh mudah untuk menunjukkan cara menggunakan kumpulan benang dan pemberitahuan penyelesaian tugas dan panggil balik.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolExample {

    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交任务，并获取Future对象
        Future<String> futureResult = executor.submit(() -> {
            // 在线程池中执行的任务
            try {
                Thread.sleep(2000); // 模拟任务耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务执行完成";
        });

        // 其他的操作可以在任务执行完成后进行
        // 可以通过isDone()方法判断任务是否执行完毕
        if (futureResult.isDone()) {
            try {
                // 获取任务执行的结果
                String result = futureResult.get();
                System.out.println(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 关闭线程池
        executor.shutdown();
    }
}

Dalam kod contoh di atas, kami mula-mula membuat kumpulan benang bersaiz tetap, dan kemudian menyerahkan tugasan melalui kaedah submit() Tugasan ini ialah ungkapan Lambda, yang mensimulasikan tugasan yang memakan masa selepas pelaksanaan selesai , rentetan akan dikembalikan. Kami mendapat hasil rentetan ini dengan memanggil kaedah get() Future dan mengeluarkannya ke konsol.

Perlu diambil perhatian bahawa kaedah get() Masa Depan menyekat, yang bermaksud bahawa program akan menjeda pelaksanaan apabila memanggil kaedah ini sehingga pelaksanaan tugas selesai dan hasilnya dikembalikan. Jika tugasan belum selesai, kaedah get() akan menyekat sehingga tugasan selesai sebelum mengembalikan hasilnya.

Selain itu, kami juga boleh menentukan sama ada tugasan selesai dengan memanggil kaedah isDone() Masa Depan untuk melaksanakan beberapa operasi lain.

Dalam pembangunan sebenar, himpunan rangkaian dan pemberitahuan penyelesaian tugas dan panggil balik boleh membantu kami menangani isu konkurensi yang kompleks dengan lebih baik. Kami boleh mengurus dan menjadualkan pelaksanaan tugas melalui kumpulan benang, dan mendapatkan hasil pelaksanaan tugas melalui pemberitahuan penyelesaian tugas dan panggilan balik untuk pemprosesan selanjutnya. Ini boleh meningkatkan kecekapan dan kebolehpercayaan program, menjadikan pembangunan kami lebih cekap dan mudah.

Ringkasnya, penggunaan kumpulan benang di Java 7 adalah sangat mudah dan fleksibel. Dengan menggunakan kumpulan rangkaian dan mekanisme pemberitahuan penyelesaian tugas dan panggil balik secara rasional, kami boleh mengendalikan tugas serentak dengan lebih baik dan meningkatkan prestasi dan kestabilan program. Ini sangat penting untuk membina aplikasi berbilang benang yang cekap dan boleh dipercayai.

(Nota: Artikel ini menggunakan Java 7 sebagai contoh, tetapi ia juga boleh digunakan untuk Java 8 dan ke atas. Beberapa contoh kod adalah daripada dokumen rasmi Oracle)

Atas ialah kandungan terperinci Cara menggunakan kumpulan benang untuk melaksanakan pemberitahuan penyelesaian tugas dan panggil balik dalam Java 7. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!