当前位置：首页 > article >正文

30分钟入门CompletableFuture并发工具使用

article 2025/2/4 12:05:28

快速学习基本方法，然后30分钟直接学会CompletableFuture的使用

异步处理：supplyAsync（）

分析Supplier接口

首先我们看看Supplier接口

这是一个函数式接口，没有入参，只有一个返回值

我们这段代码会在另一个线程执行然后return

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //业务逻辑
            return "任务结果";
        });
    }
}

等待异步结束：join（）

我们等待异步线程执行结束

public class Main {
    public static void main(String[] args) {
       

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //业务逻辑
            return "任务结果";
        });
        //我们的主线程等待异步线程执行结束才往下执行
        cf1.join();
    }
}

执行完任务1再开启任务2：thenCompose（）

我们thenCompose（）就是执行完上一个任务再开启下一个任务

我们的前一个异步操作的结果作为下一个异步操作结果的输入

我们的这个dish变量，其实就是个变量名，随便写都行，就是thenCompose（）上一个任务的执行结果

我们可以传到下一个任务中去


public class Main {
    public static void main(String[] args) {

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //执行任务1
            return "任务1的结果";
        }).thenCompose(dish -> CompletableFuture.supplyAsync(() -> {
            //执行任务2
            return "任务2的结果";
        }));

    }
}

任务1和任务2同时执行：thenCombine（）

我们任务1和任务2同时执行，然后我们会把两个任务执行的结果组合起来

然后return返回

public class Main {
    public static void main(String[] args) {


        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //执行任务1
            return "任务1的结果";
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            //执行任务2
            return "任务2的结果";
        }), (a, b) -> {
            return String.format("%s + %s 好了", a, b;
        });


    }
}

异步线程结束后，再对异步线程结果做处理：thenApply（）

和thenCompose（）的区别：thenCompose（）是开启另一个异步线程执行，而thenApply（）的目的是对异步线程的结果做处理

也就是说thenApply是进一步处理结果的，不会再开启一个新的异步线程

public class Main {
    public static void main(String[] args) {

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            return "500";
        }).thenApply(money -> {
            return String.format("%s元发票", money);
        });


    }
}

thenApplyAsync（）

和thenCompose（）差不多，省略

任务1和任务2谁先结束谁先返回：applyToEither（）

任务1和任务2，哪一个任务先结束，哪一个任务就先返回

我们的这个方法的第二个参数，是对结果进行处理

result -> result，例如我们的结果是result，我们不做处理所以还是返回result

结果要变化或者调用函数变化可以自己加

public class _02_applyToEither {
    public static void main(String[] args) {


        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //执行任务1
            return "任务1的结果";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            //执行任务2
            return "任务2的结果";
        }), result -> result);


    }
}

public class _02_applyToEither {
    public static void main(String[] args) {


        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //执行任务1
            return "任务1的结果";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            //执行任务2
            return "任务2的结果";
        }), result -> {
            //修改结果逻辑
        });


    }
}

处理异步线程的异常：exceptionally（）

public class _02_applyToEither {
    public static void main(String[] args) {


 CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            //执行任务1
            return "任务1的结果";
}).exceptionally(e -> {
    //处理报错
    return "报错";
});


    }
}

等待所有异步线程执行完：allOf（）

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
        allOf.get();// 等待所有任务完成
        System.out.println("任务1结果: " + future1.get());
        System.out.println("任务2结果: " + future2.get());
    }
}

进一步简洁使用

我们可以用一个CompletableFuture【】数组，然后allOf（）统一进行管理

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer>[] cf = new CompletableFuture[2];
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
        cf[0] = future1;
        cf[1] = future2;
        CompletableFuture<Void> allOf = CompletableFuture.allOf(cf);
        allOf.get();// 等待所有任务完成
        System.out.println("任务1结果: " + future1.get());
        System.out.println("任务2结果: " + future2.get());
    }
}

等待其中一个异步线程执行完：anyOf（）

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2);
        Object first=allOf.get();// 第一个执行完的任务的任务结果
        
        System.out.println("任务1结果: " + future1.get());
        System.out.println("任务2结果: " + future2.get());
        System.out.println(first);
    }
}

查看全文

http://www.kler.cn/a/531047.html