7.26

最新推荐文章于 2024-07-27 14:51:42 发布
最新推荐文章于 2024-07-27 14:51:42 发布
阅读量288 收藏 17
点赞数 15
文章标签： 网络 java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64201189/article/details/140718003
版权

CompletableFuture

1、supplyAsync、runAsync

在 Java 的 CompletableFuture 类中，supplyAsync 和 runAsync 是两个用于异步执行任务的方法。它们的主要区别在于处理返回值的方式和适用场景。下面详细介绍这两个方法。

1. supplyAsync

  • 功能: supplyAsync 方法用于异步执行一个可以返回结果的任务。
  • 返回值: 它返回一个 CompletableFuture<T>，其中 T 是通过任务计算得到的结果。
使用场景

适用于需要计算并返回结果的任务。

示例代码
import java.util.concurrent.CompletableFuture;

public class SupplyAsyncExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一些计算
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return 42; // 返回计算结果
        });

        // 等待结果并打印
        future.thenAccept(result -> {
            System.out.println("计算结果: " + result);
        });

        // 主线程可以继续执行其他任务
        System.out.println("主线程继续执行...");
        
        // 等待 CompletableFuture 完成
        future.join(); // 这里会阻塞直到 future 完成
    }
}

2. runAsync

  • 功能: runAsync 方法用于异步执行一个不需要返回结果的任务。
  • 返回值: 它返回一个 CompletableFuture<Void>，表示任务的完成状态。
使用场景

适用于只需执行某些操作而不需要计算返回值的任务，例如日志记录、发送通知等。

示例代码
import java.util.concurrent.CompletableFuture;

public class RunAsyncExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            // 模拟一些操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("任务完成!");
        });

        // 主线程可以继续执行其他任务
        System.out.println("主线程继续执行...");

        // 等待 CompletableFuture 完成
        future.join(); // 这里会阻塞直到 future 完成
    }
}

主要区别

特性supplyAsyncrunAsync
返回值返回计算结果的 CompletableFuture<T>返回 CompletableFuture<Void>
用途适用于需要结果的计算任务适用于不需要结果的执行操作
示例计算和返回一个值仅执行某些操作（如打印、更新状态）

总结

  • 使用 supplyAsync 当你需要执行一个计算并希望得到结果时。
  • 使用 runAsync 当你只想执行一个操作而不需要返回值时。

这两个方法都可以使你的程序在多线程环境中更加高效和响应迅速，特别适合处理 I/O 密集型或计算密集型任务。通过合理使用这两个方法，可以显著提高应用程序的性能和可扩展性。

2、allOf、anyOf

allOf

CompletableFuture.allOf 是 Java 中 CompletableFuture 类的一个静态方法，它允许你组合多个 CompletableFuture 实例，并在所有这些实例都完成时进行某种操作。allOf 返回一个新的 CompletableFuture<Void>，一旦所有传入的 CompletableFuture 都完成（无论是成功还是失败），这个新的 CompletableFuture 就会完成。

anyOf

CompletableFuture.anyOf 方法用于组合多个 CompletableFuture 实例，直到其中一个完成（成功或失败）。它返回一个新的 CompletableFuture，一旦任一给定的 CompletableFuture 完成，这个新的 CompletableFuture 就会完成，并且可以处理已完成的结果。

3、get

在 Java 的 CompletableFuture 中，get 方法用于获取 CompletableFuture 的计算结果。如果 CompletableFuture 还没有完成，调用 get 方法会导致当前线程阻塞，直到计算完成或者失败。此外，get 方法还有一个重载版本，允许你在获取结果时指定超时时间。

使用 get 方法

  1. 基本用法
    • get()：阻塞当前线程，直到计算完成并返回结果。
    • get(long timeout, TimeUnit unit)：阻塞当前线程，直到计算完成、超时或者发生异常。

示例代码

下面是一个使用 CompletableFuture.allOf 和 get 方法的示例，展示如何处理多个异步任务，并在超时情况下进行异常处理。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AllOfWithTimeoutExample {
    public static void main(String[] args) {
        // 创建多个异步任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            sleep(2000); // 模拟长时间运行的任务
            return "Result from Future 1";
        });
        
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            sleep(1000); // 模拟较短时间的任务
            return "Result from Future 2";
        });
        
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            sleep(1500); // 模拟中等时间的任务
            return "Result from Future 3";
        });

        // 使用 allOf 等待所有任务完成
        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2, future3);

        try {
            // 等待所有任务完成，设置超时时间为 3 秒
            allOfFuture.get(3, TimeUnit.SECONDS); // 如果超时，将抛出 TimeoutException

            // 获取每个 future 的结果
            String result1 = future1.get();
            String result2 = future2.get();
            String result3 = future3.get();

            // 输出结果
            System.out.println("所有任务完成:");
            System.out.println(result1);
            System.out.println(result2);
            System.out.println(result3);
        } catch (TimeoutException e) {
            System.out.println("操作超时，未能在规定时间内完成。");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
            System.out.println("任务被中断。");
        } catch (ExecutionException e) {
            System.out.println("任务执行异常: " + e.getCause());
        }
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
        }
    }
}

4、thenApply、thenAccept、thenCompose

在 Java 的 CompletableFuture 类中，thenApply、thenAccept 和 thenCompose 是用于处理异步计算结果的三个重要方法。它们允许你在 CompletableFuture 完成时定义后续操作，但它们的使用场景和返回类型各不相同。下面详细介绍这三个方法。

1. thenApply

  • 功能: thenApply 方法用于对 CompletableFuture 的结果进行转换，返回一个新的结果。
  • 返回值: 返回一个新的 CompletableFuture<U>，其中 U 是通过给定的函数处理后的结果。
使用场景

适用于需要对异步计算结果进行进一步处理并返回新结果的场景。

示例代码
import java.util.concurrent.CompletableFuture;

public class ThenApplyExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42; // 原始计算结果
        });

        CompletableFuture<String> transformedFuture = future.thenApply(result -> {
            return "结果是: " + result; // 转换结果
        });

        // 打印转换后的结果
        transformedFuture.thenAccept(System.out::println);
    }
}

2. thenAccept

  • 功能: thenAccept 方法用于处理 CompletableFuture 的结果，但不返回任何结果。
  • 返回值: 返回一个新的 CompletableFuture<Void>，表示处理完成。
使用场景

适用于只关心异步计算结果但不需要返回新结果的场景。

示例代码
import java.util.concurrent.CompletableFuture;

public class ThenAcceptExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42; // 原始计算结果
        });

        future.thenAccept(result -> {
            System.out.println("结果是: " + result); // 处理结果
        });
    }
}

3. thenCompose

  • 功能: thenCompose 方法用于将一个 CompletableFuture 的结果转换为另一个 CompletableFuture。它通常用于处理依赖于前一个 CompletableFuture 结果的异步操作。
  • 返回值: 返回一个新的 CompletableFuture<U>，其中 U 是通过给定的函数处理后的结果。
使用场景

适用于当后续操作返回 CompletableFuture 时，需要将这些操作串联在一起的场景。

示例代码
import java.util.concurrent.CompletableFuture;

public class ThenComposeExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42; // 原始计算结果
        });

        CompletableFuture<String> finalFuture = future.thenCompose(result -> {
            return CompletableFuture.supplyAsync(() -> 
                "结果是: " + result // 依赖于前一个结果的异步操作
            );
        });

        // 打印最终结果
        finalFuture.thenAccept(System.out::println);
    }
}

主要区别

方法功能返回值类型使用场景
thenApply转换结果并返回新结果CompletableFuture<U>需要对结果进行处理并返回新结果的场景
thenAccept处理结果但不返回任何结果CompletableFuture<Void>只关心计算结果但不需要返回新结果的场景
thenCompose将一个异步操作的结果与另一个异步操作链接在一起CompletableFuture<U>当后续操作需要依赖于前一个操作的结果并返回 CompletableFuture 的场景

总结

  • 使用 thenApply 当你需要对异步计算的结果进行转换并返回新结果时。
  • 使用 thenAccept 当你只想处理结果而不需要返回值时。
  • 使用 thenCompose 当你需要将一个 CompletableFuture 的结果传递给另一个异步操作时。
  • thenApply 是用于将前一个任务的结果转换为另一个结果，适合用于处理结果，不启动新的异步计算。
  • thenCompose 是用于将前一个任务的结果传递给一个返回新的 CompletableFuture 的函数，适合用于在前一个任务完成后，启动新的异步计算。

这三个方法提供了丰富的组合能力，使得使用 CompletableFuture 进行异步编程变得更加简单和灵活。通过合理使用这些方法，可以构建复杂的异步处理流程。

5、ForkJoinPool

ForkJoinPool 是 Java 中用于并行处理任务的一个线程池，特别适合处理可拆分的任务（Fork-Join 任务）。它是 Java 并发包的一部分，提供了一个高效的任务执行框架，能够充分利用多核处理器的优势。ForkJoinPool 使用了工作窃取算法（Work Stealing），使得空闲的工作线程可以窃取任务，从而提高系统的整体性能。

主要特点

  1. 可拆分任务: ForkJoinPool 特别适合处理可以被拆分成多个子任务的任务。它将大任务拆分成小任务，这些小任务可以并行执行。

  2. 工作窃取算法: 在工作窃取模型中，每个线程维护一个双端队列（Deque），当任务执行完成后，线程会尝试从自己的队列中获取新的任务。如果队列为空，线程会尝试从其他线程的队列中窃取任务。

  3. 简单的 API: ForkJoinPool 提供了简单的 API，可以通过 ForkJoinTask 类及其子类（如 RecursiveTask 和 RecursiveAction）来创建可拆分的任务。

总结

ForkJoinPool 是 Java 并发编程中的一个强大工具，适用于需要并行处理的可拆分任务。它通过工作窃取算法提高了多核处理器的利用率，并提供了简单的 API，方便开发者实现任务的分治和并行执行。通过使用 ForkJoinPool，可以显著提高计算密集型任务的性能。

6、总结

CompletableFuture 是 Java 8 引入的一个强大的工具，用于支持异步编程和并行计算。它提供了一种简洁、灵活的方式来处理异步任务，支持对结果的组合、转换和异常处理。以下是 CompletableFuture 的一些重要特点和使用概述。

主要特点

  1. 异步计算:

    • CompletableFuture 允许你在后台线程中异步执行任务，避免了阻塞主线程，从而提高应用程序的响应性。

  2. 结果组合:

    • 你可以将多个 CompletableFuture 组合在一起，通过 thenCombine、allOf、anyOf 等方法来处理多个异步操作的结果。

  3. 链式调用:

    • CompletableFuture 支持链式调用，使得你可以将多个异步操作串联在一起，形成清晰的处理流程。常用的方法包括 thenApply、thenAccept、thenCompose 等。

  4. 异常处理:

    • 提供了灵活的异常处理机制，可以使用 exceptionally、handle 和 whenComplete 方法来处理任务执行中的异常。

  5. 支持回调:

    • 可以注册回调函数，在任务完成时被调用，无论是正常完成还是异常完成。

  6. 工作窃取:

    • 基于 ForkJoinPool，CompletableFuture 可以充分利用多核处理器，提高并发执行的效率。

常用方法

  • 创建任务:

    • supplyAsync(Supplier<U> supplier)：异步执行并返回结果。
    • runAsync(Runnable runnable)：异步执行不返回结果的任务。

  • 处理结果:

    • thenApply(Function<? super T,? extends U> fn)：对结果进行转换，返回新的结果。
    • thenAccept(Consumer<? super T> action)：处理结果但不返回。
    • thenCompose(Function<? super T,? extends CompletionStage<U>> fn)：将结果转换为另一个 CompletableFuture。

  • 组合多个任务:

    • allOf(CompletableFuture<?>... cfs)：等待所有 CompletableFuture 完成。
    • anyOf(CompletableFuture<?>... cfs)：等待任意一个 CompletableFuture 完成。

  • 异常处理:

    • exceptionally(Function<Throwable, ? extends T> fn)：处理异常并提供默认值。
    • handle(BiFunction<? super T,Throwable,? extends U> fn)：处理结果和异常。

示例代码

以下是一个简单的示例，展示了如何使用 CompletableFuture 来执行异步计算并处理结果：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42; // 异步计算
        });

        future.thenApply(result -> {
            return "结果是: " + result; // 转换结果
        }).thenAccept(System.out::println) // 打印结果
          .exceptionally(ex -> {
              System.out.println("发生异常: " + ex.getMessage());
              return null;
          });
    }
}

总结

CompletableFuture 提供了一种强大而灵活的方式来处理异步编程，能够轻松地实现并发操作、结果组合和异常处理。它使得 Java 开发者能够更方便地编写非阻塞代码，提高应用程序的性能和响应性。在现代 Java 应用中，CompletableFuture 是处理异步操作的重要工具。通过合理使用 CompletableFuture，你可以构建复杂的异步处理流程，并提高代码的可读性和可维护性。

programmerXrl
关注
  • 15
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OidProducer7.26
01-27
"OidProducer7.26" 是一个专用于制作点读书的工具，它主要用于生成OID（Object Identifier）编码，这种编码技术广泛应用于教育领域，尤其是点读笔产品中。OID是一种在数字信息管理系统中用于唯一标识对象的数字序列...
winSSHD7.26
08-27
WinSSHD 是一款Windows NT/2000/XP/2003下的SSH服务器
7.26记
hardy_chi的博客
07-26 633
WWW (World Wide Web 万维网)是存储在中、数量巨大的的集合。这些文档称为，它是一种)信息，可以用于描述。等，称为超媒体(Web上的信息是由彼此关联的文档组成的，而使其连接在一起的是域名 尽管IP地址能够唯一地标记网络上的计算机，但IP地址是一长串数字，不直观，而且用户记忆十分不方便，于是人们又发明了另一套型的地址方案，即。
7.26作业
qq_62608227的博客
07-26 265
【代码】【无标题】
Immunity Canvas7.26.zip
03-10
《Immunity Canvas 7.26：深入剖析漏洞利用与逆向工程的神器》 Immunity Canvas是一款在IT安全领域中广泛使用的动态分析工具，它主要用于帮助安全研究人员和渗透测试人员进行漏洞利用和逆向工程的研究。Canvas 7.26...
foxmail 7.26
04-12
"Foxmail 7.26"是该软件的一个特定版本，这个版本可能在功能、性能和用户体验上有所优化，以满足不同用户的需求。 1. **邮件管理**：Foxmail的核心功能之一是管理多个邮件账户，允许用户在一个界面下同时查看和管理...
外链代发源码 v7.26
10-23
网站自动化宣传机器/SEO外链工具。 （新站每天两次，一星期保证各大搜索引擎收录，老站每天一次，可保证百度快照经常更新。） 被k站每天多次，每次间隔60分钟以上,有机会重新被搜索引擎收录！...SEO外链工具不支持贵...
Linux网络工具“瑞士军刀“集合
分享不一样的技术，与你一起共同成长!
07-26 243
下面结合之前的一些使用经验为大家介绍一下一些经典应用场景下，这个网络命令工具如何使用的。例如怎么查看当前服务器监听哪些端口、连接目标主机端口情况如何?平常我们在进行Linux服务器相关运维的时候，总会遇到一些网络相关的问题。我们可以借助这些小巧、功能强悍的工具帮助我们排查问题、解决问题...
S5730举例
最新发布
jjjxxxhhh123的博客
07-27 615
例子： 假设在校园网络中，某些交换机之间存在多个连接（可能是多个光纤），如果没有STP，这些多个连接可能导致数据包在网络中无限制地传输，形成网络风暴，导致整个网络瘫痪。PIM-SM通过仅在需要时在网络中传输组播数据包，减少网络带宽的占用，提高数据传输效率。[sysname-GigabitEthernet0/0/1] ospf cost 10 // 设置接口的OSPF成本，影响路径选择。综上所述，这些网络技术和配置在大学校园网络中起到关键作用，确保网络运行高效、安全和可靠，同时满足用户的多样化需求。
网络编程套接字socket
安权_code的博客
07-23 950
网络编程中的套接字（socket）是实现网络通信的关键，换句话来说，套接字像两个端点，而发送方与接收方就是通过这两个端点进行通信的，socket的意思是插座，表示插头和插座连接上后，即发送方和接收方连接上了，然后把电流通过插座流向插头对标发送方与接收方建立了链接。
使用WebSocket协议调用群发方法将消息返回客户端页面
2302_79840586的博客
07-27 826
使用WebSocket协议调用群发方法将消息返回客户端页面
H3C与VPN高级应用（七）深入探讨H3C防火墙与VPN高级应用
洛秋的博客
07-23 1109
IPSec（Internet Protocol Security）是一种用于保护IP通信的协议，通过对数据包进行加密和认证来确保数据的机密性、完整性和真实性。IPSec VPN通常用于建立安全的远程连接，保护企业内部网络与远程办公或分支机构之间的数据通信。NAT（Network Address Translation）是一种将私有IP地址转换为公共IP地址的技术，通常用于多个设备共享一个公共IP地址访问互联网。NAT有助于节约公共IP地址，同时增强内部网络的安全性。
DNS域名管理系统、搭建DNS服务
十四的博客
07-23 927
DNS概述。
【计算机网络】OSPF单区域实验
m0_65787507的博客
07-26 703
DR和BDR是由同一网段中所有的路由器根据路由优先级和Router ID通过Hello报文选举出来的，只有优先级大于0的路由器才具有选举资格。进行DR/BDR选举时每台路由器将自己选出的DR写入Hello报文中，发给网段上的每台运行OSPF协议的路由器。如果DR或BDR失效，或者有新的路由器加入网络并希望成为DR或BDR，那么它们将参与新的选举过程。4：非DR路由器将自己的LSA发送给DR，然后DR将这些LSA泛洪到整个区域，使所有路由器获得一致的LSDB，从而确保区域内路由器都能计算出相同的最短路径树。
通信原理-思科实验五：家庭终端以太网接入Internet实验
sinat_39522506的博客
07-24 318
实验五 家庭终端以太网接入Internet实验。接着配置IP地址池和虚拟模板 开启宽带拨号。1.按照上图选择对应的设备，并连接起来。5.为路由器R1配置静态路由项。7.完成终端PC2 IP配置。
Hyperledger Fabric 网络体验 - 网络启动过程概览
ALONG的博客
07-25 459
作为第一次Fabric网络体验，网络启动主要包含三个操作，分别是生成配置文件、启动网络和操作网络。执行完指令能看到fabric已经启动。
第五章上 BGP工作
璀云霄的博客
07-23 1085
第5章上 BGP工作
应用层自定义协议以及序列化和反序列化
Xpccccc的博客
07-24 998
应用层自定义协议以及序列化和反序列化
immunity canvas 7.26 虚拟机
05-21
很抱歉，我不清楚“immunity canvas 7.26 虚拟机”的具体含义。但是，Immunity Canvas是一种网络安全工具，它可以模拟恶意攻击并测试网络系统的安全性。而虚拟机是一种技术，它可以在一台计算机上同时运行多个操作系统或应用程序。因此，如果您正在使用Immunity Canvas进行网络安全测试，您可能需要使用虚拟机来运行它。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值