Analisis penggunaan Executor dan ThreadPool dalam pengaturcaraan selari Java

Antara muka Pelaksana menyediakan mekanisme pelaksanaan tugas, dan ThreadPool ialah pelaksanaannya, menguruskan kumpulan benang untuk melaksanakan tugas. ThreadPool dicipta menggunakan kelas alat Executors, seperti newFixedThreadPool(), dan menggunakan kaedah execute() untuk menyerahkan tugas. Dalam kes praktikal, ExecutorService dan ThreadPool digunakan untuk mengira jumlah kuasa dua nombor untuk menunjukkan penggunaan pengaturcaraan selari. Pertimbangan termasuk mengimbangi saiz kumpulan benang dan bilangan tugas, mengelakkan pengecualian dilemparkan dan menutup ThreadPool selepas digunakan.

Panduan Penggunaan untuk Executor dan ThreadPool dalam Java Parallel Programming

Apabila melaksanakan pengaturcaraan selari dalam Java, Executor dan ThreadPool ialah dua konsep teras. Dalam tutorial ini, kami akan melihat secara mendalam kedua-dua mekanisme dan menunjukkan cara menggunakannya melalui contoh praktikal. Executor和ThreadPool是两大核心概念。在本教程中，我们将深入探讨这两种机制，并通过实战案例演示如何使用它们。

Executor

Executor接口代表一个任务执行机制。它提供了一个通用的方法execute()，用于提交任务执行。通过实现Executor接口，可以自定义任务的执行方式，例如，创建自定义的线程池或使用现成的线程池。

public class CustomExecutor implements Executor {

    @Override
    public void execute(Runnable command) {
        // 自定义任务执行逻辑
        // ...
    }
}

ThreadPool

ThreadPool是Executor的一个实现，提供了一组线程来并行执行任务。它管理线程的生命周期，确保同时运行的任务数量不超过线程池大小。

可以使用Executors工具类创建线程池，例如newFixedThreadPool()和newCachedThreadPool()：

ExecutorService threadPool = Executors.newFixedThreadPool(5);
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        // 任务代码
    }
});

实战案例

计算数字平方

考虑一个并行计算数字平方和的场景。我们可以使用Executor和ThreadPool实现如下：

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

public class SquareSum {

    private static int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        long sum = 0;
        for (int number : numbers) {
            threadPool.execute(() -> sum += Math.pow(number, 2));
        }

        threadPool.shutdown();
        while (!threadPool.isTerminated()) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Square sum: " + sum);
    }
}

在这个案例中，Executors.newFixedThreadPool()创建了一个线程池，其大小与可用处理器的数量相匹配。然后，任务被提交到线程池，并行计算每个数字的平方。最后，shutdown()方法关闭了线程池，并等待所有任务完成。

注意事项

• 使用ThreadPool时，应注意线程池大小和任务数量的平衡。线程池过大可能导致资源浪费，而线程池过小可能导致性能瓶颈。
• 提交给Executor的任务不应抛出异常。如果一个任务抛出异常，Executor可能会失败，导致所有其他任务无法执行。
• 在使用ThreadPool后，应使用shutdown()

Executor🎜🎜🎜Executor antara muka mewakili mekanisme pelaksanaan tugas. Ia menyediakan kaedah umum execute() untuk menyerahkan tugasan untuk pelaksanaan. Dengan melaksanakan antara muka Executor, anda boleh menyesuaikan cara tugasan dilaksanakan, contohnya, mencipta kumpulan benang tersuai atau menggunakan kumpulan benang siap sedia. 🎜rrreee🎜🎜ThreadPool🎜🎜🎜ThreadPool ialah pelaksanaan Executor, yang menyediakan satu set urutan untuk melaksanakan tugas secara selari. Ia menguruskan kitaran hayat benang dan memastikan bilangan tugasan yang dijalankan serentak tidak melebihi saiz kolam benang. 🎜🎜Anda boleh menggunakan kelas alat Executors untuk mencipta kumpulan benang, seperti newFixedThreadPool() dan newCachedThreadPool(): 🎜rrreee🎜🎜 Kes praktikal🎜🎜🎜 🎜Kira kuasa dua nombor🎜🎜🎜Pertimbangkan senario di mana jumlah kuasa dua nombor dikira secara selari. Kita boleh menggunakan Executor dan ThreadPool untuk mencapai perkara berikut: 🎜rrreee🎜Dalam kes ini, Executors.newFixedThreadPool() mencipta kumpulan benang yang Saiznya sepadan dengan bilangan pemproses yang tersedia. Kemudian, tugasan diserahkan kepada kumpulan benang untuk mengira kuasa dua setiap nombor secara selari. Akhir sekali, kaedah shutdown() menutup kumpulan benang dan menunggu semua tugasan selesai. 🎜🎜🎜Nota🎜🎜

• Apabila menggunakan ThreadPool, anda harus memberi perhatian kepada keseimbangan antara saiz kumpulan benang dan bilangan tugasan. Kumpulan benang yang terlalu besar boleh menyebabkan pembaziran sumber, manakala kumpulan benang yang terlalu kecil boleh menyebabkan kesesakan prestasi. 🎜
• Tugas yang diserahkan kepada Pelaksana tidak seharusnya membuang pengecualian. Jika tugasan memberikan pengecualian, Executor mungkin gagal, menghalang semua tugasan lain daripada melaksanakan. 🎜
• Selepas menggunakan ThreadPool, kumpulan benang hendaklah ditutup menggunakan kaedah shutdown() untuk memastikan semua rangkaian telah dihentikan. 🎜🎜

Atas ialah kandungan terperinci Analisis penggunaan Executor dan ThreadPool dalam pengaturcaraan selari Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!