Bagaimana untuk menggunakan Masa Depan dan Boleh Dipanggil untuk pengaturcaraan tak segerak dalam pengaturcaraan serentak Java?

Gunakan Masa Depan dan Boleh Dipanggil untuk pengaturcaraan tak segerak Java: Masa Depan merangkum hasil operasi tak segerak, dan memperoleh nilai pulangan melalui kaedah get(). Boleh dipanggil digunakan untuk mencipta tugas tak segerak, sama seperti Runnable tetapi boleh mengembalikan nilai. Dalam contoh, tugas Boleh Panggil dicipta dan diserahkan kepada perkhidmatan pelaksana untuk pelaksanaan tak segerak. Benang utama terus melaksanakan tugas lain, dan apabila keputusan diperlukan, hubungi Future.get() untuk mendapatkannya. Akhirnya tutup perkhidmatan pelaksana untuk melepaskan sumber.

Pengaturcaraan Asynchronous dalam Java Concurrent Programming menggunakan Future and Callable

Pengenalan

Pengaturcaraan tak segerak ialah teknik yang membenarkan pelaksanaan serentak tugasan utama tanpa menyekat. Di Java, pengaturcaraan tak segerak boleh dilaksanakan menggunakan antara muka Masa Depan dan Boleh Panggil.

Masa hadapan

Masa hadapan ialah hasil enkapsulasi operasi tak segerak. Ia digunakan untuk mendapatkan nilai pulangan tugasan, walaupun tugasan itu belum selesai. Future menyediakan kaedah get(), yang akan mengembalikan hasilnya apabila tugasan selesai. get() 方法，当任务完成时，它将返回结果。

Callable

Callable 是一个用于创建异步任务的接口。它与 Runnable 接口类似，但是 Callable 可以返回一个值，而 Runnable 只能执行一个操作。

异步编程示例

下面是一个使用 Future 和 Callable 进行异步编程的示例：

import java.util.concurrent.*;

public class AsyncExample {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // 创建 Callable 任务，它将执行一个耗时的操作并返回结果
        Callable<Integer> task = () -> {
            // 模拟耗时的任务
            Thread.sleep(1000);
            return 42;
        };

        // 将 Callable 任务提交到执行器服务，它将异步执行任务
        Future<Integer> future = executorService.submit(task);

        // 主线程可以继续执行其他任务，而不必等待 Callable 任务完成
        System.out.println("Main thread is doing other work.");

        // 当需要结果时，可以调用 Future 的 get() 方法来获取它
        try {
            // 等待任务完成并获取结果
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            // 处理任务中断或执行异常
            e.printStackTrace();
        } finally {
            // 关闭执行器服务以释放资源
            executorService.shutdown();
        }
    }
}

在这个示例中：

• task 是一个 Callable 任务，它执行一个耗时的操作并返回结果。
• future 是一个 Future，它封装了 Callable 任务的结果。
• executorService 是一个执行器服务，它用于异步执行 Callable 任务。
• 主线程在提交任务后可以继续执行其他任务，无需等待任务完成。
• 当需要结果时，主线程可以调用 future.get()

Boleh Dipanggil🎜🎜🎜Boleh Dipanggil ialah antara muka untuk mencipta tugas tak segerak. Ia serupa dengan antara muka Runnable, tetapi Callable boleh mengembalikan nilai, manakala Runnable hanya boleh melakukan satu operasi. 🎜🎜🎜Contoh Pengaturcaraan Tak Segerak🎜🎜🎜Berikut ialah contoh pengaturcaraan tak segerak menggunakan Masa Depan dan Boleh Dipanggil: 🎜rrreee🎜Dalam contoh ini: 🎜

• tugas ialah tugas Boleh Panggil, Ia melaksanakan operasi yang memakan masa dan mengembalikan hasilnya. 🎜
• masa depan ialah Masa Depan yang merangkumi hasil tugasan Boleh Panggil. 🎜
• executorService ialah perkhidmatan pelaksana, yang digunakan untuk melaksanakan tugas Boleh Panggil secara tidak segerak. 🎜
• Urut utama boleh terus melaksanakan tugasan lain selepas menyerahkan tugasan tanpa menunggu tugasan selesai. 🎜
• Apabila keputusan diperlukan, urutan utama boleh memanggil kaedah future.get() untuk mendapatkannya. 🎜🎜

Atas ialah kandungan terperinci Bagaimana untuk menggunakan Masa Depan dan Boleh Dipanggil untuk pengaturcaraan tak segerak dalam pengaturcaraan serentak Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!