Cara menggunakan kumpulan benang dalam Java 7 untuk mengendalikan hasil pemulangan tugas berbilang benang

Cara menggunakan kumpulan benang untuk mengendalikan hasil pengembalian tugas berbilang benang dalam Java 7

Apabila membangunkan aplikasi Java, selalunya perlu memproses tugas berbilang benang dan mendapatkan hasil pulangan benang. Menggunakan kumpulan benang boleh mengurus sumber benang dengan lebih baik dan dapat mengendalikan hasil pengembalian tugas berbilang benang. Artikel ini akan memperkenalkan cara menggunakan kumpulan benang untuk mengendalikan hasil pengembalian tugas berbilang benang dalam Java 7 dan menyediakan contoh kod.

Kolam benang ialah mekanisme untuk mengurus dan menggunakan semula sumber benang. Melalui kumpulan benang, anda boleh membuat utas apabila diperlukan dan bukannya membuat utas baharu setiap kali anda memulakan utas. Kumpulan benang boleh meningkatkan prestasi aplikasi dan mengurangkan overhed penciptaan dan pemusnahan benang.

Dalam Java 7, anda boleh menggunakan kelas Executors untuk mencipta kumpulan benang. Berikut ialah contoh kod untuk membuat himpunan benang: Executors类来创建线程池。以下是一个创建线程池的示例代码：

ExecutorService executor = Executors.newFixedThreadPool(10);

上面的代码将创建一个含有10个线程的线程池。接下来，我们将使用线程池来执行多线程任务，并获取线程的返回结果。

假设有一个任务列表，其中每个任务都需要在独立的线程中执行，并返回执行的结果。以下是一个示例的任务类：

public class Task implements Callable<String> {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        // 执行任务的代码
        Thread.sleep(1000);
        return "Task " + name + " has been completed";
    }
}

在上面的代码中，Task类实现了Callable接口，并且指定了返回结果的类型为String。call()方法中包含了要执行的任务的代码。在这个示例中，只是简单地让线程休眠1秒钟，并返回一个字符串。

接下来，我们将使用线程池来执行这些任务，并获取线程的返回结果。以下是一个使用线程池处理任务的示例代码：

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        List<Future<String>> results = new ArrayList<>();
        
        for (int i = 0; i < 10; i++) {
            Task task = new Task("Task " + i);
            results.add(executor.submit(task));
        }
        
        executor.shutdown();
        
        for (Future<String> result : results) {
            try {
                System.out.println(result.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

在上面的代码中，首先创建了一个线程池，然后创建一个ArrayList来存储Future对象，这些对象代表了线程任务的状态和结果。

接下来，通过一个循环创建了10个Task实例，将其提交到线程池中，并将Future对象添加到结果列表中。

然后，调用线程池的shutdown()方法来关闭线程池。

最后，通过另一个循环遍历结果列表，使用Future对象的get()

Task 0 has been completed
Task 1 has been completed
Task 2 has been completed
Task 3 has been completed
Task 4 has been completed
Task 5 has been completed
Task 6 has been completed
Task 7 has been completed
Task 8 has been completed
Task 9 has been completed

Kod di atas akan mencipta kumpulan benang dengan 10 utas. Seterusnya, kami akan menggunakan kumpulan benang untuk melaksanakan tugas berbilang benang dan mendapatkan hasil pulangan benang.

Andaikan terdapat senarai tugasan, setiap satunya perlu dilaksanakan dalam urutan bebas dan hasil pelaksanaan dikembalikan. Berikut ialah contoh kelas tugas:

rrreee

Dalam kod di atas, kelas Task melaksanakan antara muka Callable dan menentukan jenis hasil pulangan sebagai String kod>. Kaedah <code>call() mengandungi kod untuk tugasan yang akan dilakukan. Dalam contoh ini, benang hanya tidur selama 1 saat dan mengembalikan rentetan.

Seterusnya, kami akan menggunakan kumpulan benang untuk melaksanakan tugasan ini dan mendapatkan hasil pulangan benang. Berikut ialah kod sampel yang menggunakan kumpulan benang untuk mengendalikan tugasan: 🎜rrreee🎜 Dalam kod di atas, kumpulan benang pertama kali dibuat dan kemudian ArrayList dicipta untuk menyimpan Future object , objek ini mewakili status dan hasil tugasan benang. 🎜🎜Seterusnya, 10 kejadian Task dibuat melalui gelung, diserahkan kepada kumpulan benang dan objek Future ditambahkan pada senarai hasil. 🎜🎜Kemudian, panggil kaedah shutdown() kumpulan benang untuk menutup kumpulan benang. 🎜🎜Akhir sekali, lalui senarai hasil melalui gelung lain, gunakan kaedah get() objek Future untuk mendapatkan hasil pemulangan benang dan cetak hasilnya. 🎜🎜Jalankan kod di atas, kita akan mendapat output yang serupa dengan yang berikut: 🎜rrreee🎜Kod di atas menunjukkan cara menggunakan kumpulan benang untuk mengendalikan hasil pengembalian tugas berbilang benang. Dengan menggunakan kumpulan benang, kami boleh mengurus sumber benang dengan lebih baik dan memperoleh hasil pulangan benang dengan lebih mudah. 🎜🎜Sila ambil perhatian bahawa kumpulan benang dan kelas berkaitan Java 7 digunakan dalam contoh dalam artikel ini. Di Java 8, kumpulan benang yang lebih berkuasa dan fleksibel serta kelas utiliti konkurensi telah diperkenalkan. Jika anda sedang membangun dalam Java 8 dan ke atas, adalah disyorkan untuk menggunakan kelas alat konkurensi Java 8 untuk mengendalikan hasil pengembalian tugas berbilang benang. 🎜

Atas ialah kandungan terperinci Cara menggunakan kumpulan benang dalam Java 7 untuk mengendalikan hasil pemulangan tugas berbilang benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!