Java多线程学习笔记（二）

企业开发 2023-04-09 15:05:46 阅读次数: 0

目录

一、Future接口

java.util.concurrent包下，有以下方法：

  • cancel(boolean var1)：取消Callable任务，未开始或已完成返回false，boolean参数表示是否中断执行中的Callable任务
  • isCanceled()：判断Callable任务是否取消了
  • isDone()：判断是否完成
  • get()：获得Callable的返回值
  • get(long time, TimeUnit unit)：设置超时时间，防止无限时间的等待

二、CompletionStage接口

java.util.concurrent包下，jdk1.8才引入。用于阶段处理，实现链式的阶段型的操作，使线程与线程之间可以愉快的进行对话。目前只有CompletableFuture一个实现类。

1、串行执行，方法前缀then和runAfterBoth方法

后缀带Async，可以用线程池异步处理，默认线程池ForkJoinPool，3个一组，共27个方法：
在这里插入图片描述

1）、thenRun方法，前一阶段结果不影响，无返回

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
    System.out.println("main线程start");
    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("线程名称：" + Thread.currentThread().getName());
        return 1;
    }).thenRunAsync(() -> {
    
    
        System.out.println("线程名称：" + Thread.currentThread().getName());
    }, EXECUTOR_SERVICE);

    future.get();
    System.out.println("main线程end");
}

输出结果：
在这里插入图片描述

2）、thenAccept方法，前一阶段结果变入参，无返回

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
    System.out.println("main线程start");
    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("线程名称：" + Thread.currentThread().getName());
        return 1;
    }).thenAccept((t) -> {
    
    
        System.out.println("线程名称：" + Thread.currentThread().getName());
        System.out.println(t);
    });

    future.get();
    System.out.println("main线程end");
}

输出结果：
在这里插入图片描述

3）、thenApply方法，前一阶段结果变入参，有返回

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
    System.out.println("main线程start");
    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("线程名称：" + Thread.currentThread().getName());
        return 1;
    }).thenApply((t) -> {
    
    
        System.out.println("线程名称：" + Thread.currentThread().getName());
        System.out.println(t);
        return t;
    });

    Integer t = future.get();
    System.out.println("返回结果：" + t);
    System.out.println("main线程end");
}

输出结果：
在这里插入图片描述

4）、thenCombine方法，前一阶段 f1 和 f2 的结果变入参，有返回

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
        System.out.println("main线程start");

        CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(2000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("f1线程名称：" + Thread.currentThread().getName());
            return 1;
        });

        CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("f2线程名称：" + Thread.currentThread().getName());
            return 2;
        }).thenCombine(f1, (t, u) -> {
    
    
            System.out.println("结合后线程名称：" + Thread.currentThread().getName());
            System.out.println("t：" + t);
            System.out.println("u：" + u);
            return t + u;
        });

        Integer result = f2.get();
        System.out.println("返回结果：" + result);
        System.out.println("main线程end");
    }

输出结果：
在这里插入图片描述

5）、thenAcceptBoth方法（和thenCombine方法一样，只是无返回）

6）、runAfterBoth方法（和thenCombine方法一样，只是无返回、无入参）

7）、thenCompose方法（和thenApply方法一样，只是传入函数的返回是CompletableFuture<>）

8）、whenComplete方法，入参多了一个异常，无返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
    System.out.println("main线程start");
    CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(2000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("f1线程名称：" + Thread.currentThread().getName());
//            return 1;
        throw new RuntimeException("异常了！");
    }).whenComplete((t, u) -> {
    
    
        System.out.println("f2线程名称：" + Thread.currentThread().getName());
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        if (u != null) {
    
    
            System.out.println("异常1");
            u.printStackTrace();
        } else {
    
    
            System.out.println("接收到结果：" + t);
        }
    }).thenCompose((t) -> {
    
    
        System.out.println("thenCompose线程名称：" + Thread.currentThread().getName());
        System.out.println(t);
        return CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(4000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("f3线程名称：" + Thread.currentThread().getName());
            return 2;
        });
    }).exceptionally((t) -> {
    
    
        System.out.println("f4线程名称：" + Thread.currentThread().getName());
        try {
    
    
            Thread.sleep(3000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("异常2");
        t.printStackTrace();
        return 3;
    });
    Integer result = f1.get();
    System.out.println("返回结果：" + result);
    System.out.println("main线程end");
}

输出结果：
在这里插入图片描述

9）、handle方法，和whenComplete方法一样，多了返回值

2、前一阶段的两个任务中，只需完成一个就执行后面的

在这里插入图片描述

1）、applyToEither方法，只需要前一阶段其中一个任务执行完，就会执行，并将其结果作为入参，有返回值

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
    System.out.println("main线程start");
    CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(2000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("f1线程名称：" + Thread.currentThread().getName());
        return 1;
    });
    CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("f2线程名称：" + Thread.currentThread().getName());
        return 2;
    }).applyToEither(f1, (t) -> {
    
    
        System.out.println("结合后线程名称：" + Thread.currentThread().getName());
        System.out.println("t：" + t);
        return t;
    });
    Integer result = f2.get();
    System.out.println("返回结果：" + result);
    System.out.println("main线程end");
}

输出结果：
在这里插入图片描述

2）、acceptEither方法（和applyToEither方法一样，只是无返回）

3）、runAfterEither方法（和applyToEither方法一样，只是无返回、无入参）

3、异常处理

1）、exceptionally方法，捕获异常

public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
    System.out.println("main线程start");
    CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> {
    
    
        try {
    
    
            Thread.sleep(2000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("f1线程名称：" + Thread.currentThread().getName());
        throw new RuntimeException("异常了！");
    }).thenCompose((t) -> {
    
    
        System.out.println("thenCompose线程名称：" + Thread.currentThread().getName());
        System.out.println(t);
        return CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("f2线程名称：" + Thread.currentThread().getName());
            return 2;
        });
    }).exceptionally((t) -> {
    
    
        System.out.println("f3线程名称：" + Thread.currentThread().getName());
        try {
    
    
            Thread.sleep(3000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        t.printStackTrace();
        return 3;
    });
    Integer result = f1.get();
    System.out.println("返回结果：" + result);
    System.out.println("main线程end");
}

输出结果：
在这里插入图片描述

三、多线程学习笔记

Java多线程学习笔记（一）

猜你喜欢

转载自blog.csdn.net/qq_36514197/article/details/123135140
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022