Cara menggunakan fungsi ExecutorCompletionService dalam Java untuk penjadualan tugas kumpulan benang

Dengan perkembangan teknologi Internet, kepentingan pengaturcaraan berbilang benang telah menjadi semakin menonjol. Apabila menulis program konkurensi tinggi, menggunakan sepenuhnya teknologi multi-threading boleh meningkatkan kecekapan pelaksanaan program dengan banyak. Walau bagaimanapun, pengaturcaraan berbilang benang itu sendiri melibatkan banyak isu, seperti komunikasi antara benang, kerjasama penyegerakan, dsb. Untuk menyelesaikan masalah ini, Java menyediakan banyak rangka kerja kumpulan benang, antaranya ExecutorCompletionService adalah salah satu daripadanya. Artikel ini akan memperkenalkan penggunaan ExecutorCompletionService dan cara menggunakan fungsi ini untuk penjadualan tugas kumpulan benang.

1. Gambaran Keseluruhan ExecutorCompletionService

ExecutorCompletionService ialah lanjutan daripada rangka kerja Executor dalam Java Ia mengekalkan kumpulan benang untuk melaksanakan satu set tugasan tak segerak dan menyimpan hasil tugasan ini dalam baris gilir. ExecutorCompletionService membolehkan kami memperoleh hasil dalam tugasan yang telah selesai. ExecutorCompletionService menyediakan kaedah Future submit(Cllable task) dan kaedah Future yang pertama menyerahkan tugasan ke kumpulan thread dan mengembalikan objek Future, dan yang terakhir memperoleh tugasan yang telah selesai hasil giliran.

Kelebihan utama ExecutorCompletionService ialah ia mengurangkan masa menunggu semua tugasan selesai. Apabila tugasan selesai, kita boleh mendapatkan keputusannya serta-merta tanpa menunggu semua tugasan lain selesai. Dengan cara ini, kami boleh memproses tugasan yang telah siap seawal mungkin tanpa menunggu semua tugasan disiapkan sebelum memprosesnya. Kaedah ini dapat meningkatkan kecekapan pelaksanaan program dengan berkesan.

2. Penggunaan ExecutorCompletionService

Apabila menggunakan ExecutorCompletionService, kita perlu mencipta objek ExecutorService terlebih dahulu. ExecutorService ialah rangka kerja kumpulan benang di Jawa yang boleh mengekalkan satu set utas untuk melaksanakan satu siri tugas. Kita boleh menggunakan kaedah kilang yang disediakan oleh kelas Executors untuk mencipta objek ExecutorService. Berikut ialah contoh kod untuk mencipta objek ExecutorService:

ExecutorService executor = Executors.newFixedThreadPool(10);

Sekumpulan benang bersaiz 10 dicipta di sini.

Seterusnya, kami mencipta objek ExecutorCompletionService dan menggunakannya untuk menyerahkan tugasan ke kumpulan benang:

ExecutorCompletionService<String> completionService = new ExecutorCompletionService<>(executor);
for (int i = 0; i < 10; i++) {
    final int taskId = i;
    completionService.submit(() -> {
        String result = doSomeTask(taskId);
        return result;
    });
}

Di sini, 10 tugasan diserahkan menggunakan gelung for, setiap tugas ialah objek jenis Boleh Panggil. Dalam contoh ini, kami menggunakan ungkapan Lambda untuk mencipta objek Boleh Panggil, yang merupakan ciri baharu yang diperkenalkan dalam Java 8.

Dalam kaedah serah, kami menghantar objek Boleh Panggil, melaksanakan "tugas" hipotesis dalam objek Boleh Panggil ini dan mengembalikan hasil. Dalam senario perniagaan sebenar, pemprosesan data sebenar, permintaan rangkaian dan operasi lain boleh dilakukan di sini.

Selepas menghantar tugasan, kita boleh menggunakan kaedah ambil untuk mendapatkan hasil tugasan yang telah selesai:

for (int i = 0; i < 10; i++) {
    Future<String> future = completionService.take();
    String result = future.get();
    System.out.println("Task " + i + " result: " + result);
}

Di sini, gelung for digunakan untuk mendapatkan hasil daripada tugasan yang telah disiapkan untuk mendapatkan objek Masa Depan , dan gunakan kaedah dapatkan. Boleh mendapatkan hasil tugasan. Di sini hasilnya adalah output ke konsol.

3. Penalaan prestasi kumpulan benang

Selain menggunakan ExecutorCompletionService untuk memudahkan proses penyerahan tugas dan pemerolehan hasil, kami juga perlu mempertimbangkan penalaan prestasi kumpulan benang. Bilangan benang dalam kumpulan benang dan saiz baris gilir akan memberi kesan kepada prestasi program.

Meningkatkan bilangan utas secara langsung akan menyebabkan dua masalah: pertama, penukaran konteks antara utas akan meningkat, yang akan menjejaskan prestasi program kedua, utas dalam kumpulan benang boleh menggunakan sumber sistem dengan mudah, menyebabkan beban sistem menjadi terlalu tinggi dan masalah lain berlaku. Oleh itu, kita perlu melaraskan saiz kolam benang mengikut senario perniagaan sebenar.

Saiz baris gilir secara langsung mempengaruhi keupayaan pemprosesan serentak kumpulan benang. Jika saiz baris gilir terlalu kecil, ia akan menyebabkan kumpulan benang melaksanakan dengan sangat pantas dan menggunakan sumber sistem dengan cepat jika saiz baris gilir terlalu besar, ia akan menyebabkan kumpulan benang melaksanakan dengan sangat perlahan dan tidak dapat mengekalkannya kecekapan program. Oleh itu, kita perlu melaraskan saiz baris gilir mengikut senario perniagaan sebenar.

Ringkasnya, penalaan prestasi kumpulan benang perlu berdasarkan senario perniagaan sebenar. Sekadar meningkatkan saiz kolam benang dan saiz baris gilir tidak menjamin kecekapan program Kami perlu membuat pelarasan mengikut situasi sebenar.

4. Kesimpulan

Artikel ini memperkenalkan penggunaan fungsi ExecutorCompletionService dalam Java dan cara menggunakan fungsi ini untuk penjadualan tugas kumpulan benang. Melalui ExecutorCompletionService, kami boleh menyerahkan tugasan dan mendapatkan hasil pelaksanaan tugas dengan lebih mudah, seterusnya meningkatkan kecekapan pelaksanaan program. Pada masa yang sama, artikel ini juga memperkenalkan secara ringkas penalaan prestasi kumpulan benang untuk membantu kami mengoptimumkan kod kami dengan lebih baik.

Atas ialah kandungan terperinci Cara menggunakan fungsi ExecutorCompletionService dalam Java untuk penjadualan tugas kumpulan benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!