在CompletableFuture中执行不同签名的方法
CompletableFuture是Java 8引入的一个强大的异步编程工具，它提供了一种方便的方式来处理异步操作和并发任务。CompletableFuture类中有多个方法可以执行不同签名的方法，下面是对这些方法的解释：
thenApply(Function<? super T,? extends U> fn)：该方法接收一个Function函数作为参数，用于对CompletableFuture的结果进行转换处理。它会返回一个新的CompletableFuture对象，该对象的结果类型为函数的返回类型。thenAccept(Consumer<? super T> action)：该方法接收一个Consumer函数作为参数，用于对CompletableFuture的结果进行消费处理。它不会返回任何结果，只是对结果进行处理。thenRun(Runnable action)：该方法接收一个Runnable函数作为参数，用于在CompletableFuture完成后执行一些操作。它不会接收CompletableFuture的结果，也不会返回任何结果。thenCompose(Function<? super T,? extends CompletionStage<U>> fn)：该方法接收一个Function函数作为参数，用于对CompletableFuture的结果进行转换处理，并返回一个新的CompletionStage对象。不同于thenApply方法，该方法的函数参数返回的是一个CompletionStage对象，可以用于串联多个CompletableFuture。thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)：该方法接收一个CompletionStage对象和一个BiFunction函数作为参数，用于将当前CompletableFuture的结果与另一个CompletionStage的结果进行组合处理。它会返回一个新的CompletableFuture对象，该对象的结果类型为函数的返回类型。thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)：该方法接收一个CompletionStage对象和一个BiConsumer函数作为参数，用于对当前CompletableFuture的结果和另一个CompletionStage的结果进行消费处理。它不会返回任何结果，只是对结果进行处理。runAfterBoth(CompletionStage<?> other, Runnable action)：该方法接收一个CompletionStage对象和一个Runnable函数作为参数，用于在当前CompletableFuture和另一个CompletionStage都完成后执行一些操作。它不会接收CompletableFuture的结果，也不会返回任何结果。applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn)：该方法接收一个CompletionStage对象和一个Function函数作为参数，用于对当前CompletableFuture和另一个CompletionStage中最先完成的结果进行转换处理。它会返回一个新的CompletableFuture对象，该对象的结果类型为函数的返回类型。acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)：该方法接收一个CompletionStage对象和一个Consumer函数作为参数，用于对当前CompletableFuture和另一个CompletionStage中最先完成的结果进行消费处理。它不会返回任何结果，只是对结果进行处理。runAfterEither(CompletionStage<?> other, Runnable action)：该方法接收一个CompletionStage对象和一个Runnable函数作为参数，用于在当前CompletableFuture和另一个CompletionStage中最先完成后执行一些操作。它不会接收CompletableFuture的结果，也不会返回任何结果。
以上是CompletableFuture类中执行不同签名的方法的介绍。CompletableFuture提供了丰富的方法来处理异步操作的结果，可以根据具体的需求选择合适的方法进行处理。在实际应用中，可以根据业务场景选择适当的方法来实现异步编程和并发任务的处理。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数（云原生无服务器计算服务）：https://cloud.tencent.com/product/scf
- 腾讯云数据库（云原生数据库服务）：https://cloud.tencent.com/product/cdb
- 腾讯云容器服务（云原生容器化部署服务）：https://cloud.tencent.com/product/tke
- 腾讯云CDN（内容分发网络服务）：https://cloud.tencent.com/product/cdn
- 腾讯云人工智能（AI服务）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（IoT服务）：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发（移动应用开发服务）：https://cloud.tencent.com/product/mobdev
- 腾讯云对象存储（云原生对象存储服务）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（区块链服务）：https://cloud.tencent.com/product/baas
- 腾讯云游戏多媒体引擎（游戏多媒体处理服务）：https://cloud.tencent.com/product/gme
- 腾讯云直播（音视频直播服务）：https://cloud.tencent.com/product/live
相关·内容
我正在试验来自JDK8的JDK8 API，从它中尝试acceptEither()方法。请看下面的代码(然后我将提出我的关切)：
public class AcceptEither {
public static void main(String[] args) {
CompletableFuture<Double> completableFuture2
= CompletableFuture.supplyAsync(TaskSupplier::getSomeArbitraryDouble);
CompletableFu
浏览 2提问于2016-01-16得票数 2
回答已采纳
我在库中公开了一个方法，它返回一个CompletableFuture。该方法的计算发生在一个单线程执行器上，这是我的瓶颈，因此我不希望任何后续的工作发生在同一个线程上。
如果我使用返回"supplyAsync“结果的简单方法，我将向调用方公开我宝贵的线程，调用方可能会添加同步操作(例如，通过thenAccept)，这可能会在该线程上花费一些CPU时间。
转载如下：
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.con
浏览 0提问于2019-06-09得票数 3
回答已采纳
代码： Spring代码段：
@Component
class myService {
private CSVFileProcessor csvFileProcessor;
public myService(CSVFileProcessor csvFileProcessor) {
this.csvFileProcessor=csvFileProcessor;
}
/* input: List of promises/futures obtained by reading
* csv files from S3 bucket
*
* outp
浏览 3提问于2020-03-04得票数 2
回答已采纳
对不起，在函数式编程中，它似乎是非常基本的，但我不明白这个想法。实际上，我的代码中有一个方法，它使用一个方法和另一个param作为参数。
private <R> CompletableFuture<R> retryRequest(Supplier<CompletableFuture<R>> supplier, int maxRetries)
我想调用这个函数并传递另一个方法(AnOtherMethod)，该方法接受一个整数参数：
CompletableFuture<Boolean> retry = this.retryRequest(
浏览 2提问于2020-05-06得票数 1
回答已采纳
我想创建一个带有返回值的CompletableFuture，它在Kotlin中的特定执行器上运行。 下面的代码运行得很好。 return CompletableFuture.supplyAsync {
val commandHandler = registry.get<TCommand, TResponse>(command::class.java)
commandHandler.handle(command)
} 但是，当我试图传递executor时，它不会编译。 return CompletableFuture.supplyAsync({
浏览 26提问于2019-01-22得票数 5
回答已采纳
我正在尝试扩展CompletableFuture以在thenCompose之后执行handle，但是我得到了一个编译器错误：
Type mismatch: cannot convert from CompletableFuture(Object) to CompletableFuture(U)
这是我的密码：
public class MyCompletableFuture<T> extends CompletableFuture<T> {
public <U> CompletableFuture<U> handleAndCompose
浏览 5提问于2016-03-31得票数 2
回答已采纳
我有两个服务电话：
String call1() { ... return "ok"; }
void call2(String) { ... }
我知道CompletableFuture使用回调的基本方法是
CompletableFuture<Void> future = CompletableFuture
.supplyAsync(() -> call1())
.thenAccept(s -> call2(s));
future.join();
如果我将两个链接的CompletableFutures分开，比如：
CompletableFuture<
浏览 0提问于2018-09-01得票数 4
我有一个用例，在这个用例中，我必须从一个函数返回一个CompletableFuture<Void>，该函数基于一个条件构成两个可完成的期货。
下面是我现在的情况-
private CompletableFuture<Void> processSomething(final SomeEvent event) {
final CompletableFuture<PaginatedQueryList<Detail>> detail = dao.getData(event.getOrderId());
return detail.then
浏览 3提问于2019-12-06得票数 0
回答已采纳
我将我的项目迁移到Kotlin，这一阶段Java和Kotlin之间有很多交互。 在下面的示例中，我需要传递一个实现Java供应商接口的函数。 java.util.concurrent.CompletableFuture.supplyAsync<Int>({ -> 3 }, executor)
CompletableFuture.supplyAsync({ 3 }, executor) IntellJ显示错误： Type mismatch.
Required: Supplier<Int!>!
Found: () -> Int 我找到了一个帮助器类的变通方法
浏览 16提问于2019-09-11得票数 2
回答已采纳
我遇到了Java 8 CompletableFuture thenCompose方法的奇怪行为。我有两个测试，它们的执行顺序不同。这两个测试都模拟了在CompletableFuture中生成的thenCompose中的失败。
@Test
public void completedAfter() {
CompletableFuture<String> future1 = new CompletableFuture<>();
CompletableFuture<String> future2 = new CompletableFuture<
浏览 6提问于2015-01-02得票数 7
回答已采纳
2回答
下面的示例取自
@Service
public class GitHubLookupService {
@Async
public CompletableFuture<User> findUser(String user) throws InterruptedException {
logger.info("Looking up " + user);
String url = String.format("https://api.github.com/users/%s", user);
User results =
浏览 5提问于2020-07-26得票数 0
回答已采纳
对于可完成的期货，我是新手，我试图了解在CompletableFuture上注册的回调线程是在哪个线程上使用构造函数(())构造的。
例如：
CompletableFuture<String> future =
CompletableFuture.supplyAsync(() -> {
//...
}, pool);
CompletableFuture<Integer> intFuture =
future.thenApply(s -> s.length());
thenApply()中的转换是
浏览 0提问于2019-05-29得票数 1
回答已采纳
要并行或异步运行某些程序，我可以使用ExecutorService：<T> Future<T> submit(Runnable task, T result);或CompletableFuture Api:static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor); (假设我在这两种情况下都使用相同的执行器)
除了返回类型Future和CompletableFuture之外，还有什么显着的区别吗？或者什么时候使用什么？
如果我
浏览 3提问于2016-09-13得票数 49
回答已采纳
这个问题不同于这个，因为我想知道作者使用thenCompose而不是thenComposeAsync的原因是什么。
我当时正在阅读“运行中的现代Java”，我在405页上看到了代码的这一部分：
public static List<String> findPrices(String product) {
ExecutorService executor = Executors.newFixedThreadPool(10);
List<Shop> shops = Arrays.asList(new Shop(), new Shop());
List
浏览 5提问于2020-08-02得票数 9
回答已采纳
我正在通过CompletableFuture API学习并发性。假设我有两项任务:一项是250毫秒，另一项是2500毫秒。在以下代码中：
Supplier<List<Long>> supplyIds = () -> {
sleep(200);
return(Arrays.asList(1L, 2L, 3L));
};
Function<List<Long>, CompletableFuture<List<User>>>
浏览 7提问于2020-04-18得票数 1
回答已采纳
有两个可完成的期货cf1和cf2定义如下：
CompletableFuture<Boolean> cf1 = CompletableFuture.completedFuture(true);
CompletableFuture<Boolean> cf2 = CompletableFuture.completedFuture(true);
从技术上讲，可以这样做：
var result1 = cf1.get();
var result2 = cf2.get();
assertThat(result1).isEqualTo(result2);
例如，如果只有一个未来，我
浏览 16提问于2022-09-16得票数 1
回答已采纳
当我单独运行runAsyncWithMock测试时，它会等待3秒，直到模拟的执行完成，而不是像其他两个测试那样被终止。
我不知道为什么。
有趣的是：
当多个Runnables由CompletableFuture.runAsync在runAsyncWithMock测试中的一行中执行时，只有第一个等待，其他不等待。
当有多个重复的runAsyncWithMock测试时，每个测试都会在执行整个规范时运行3s。
当使用Class实例而不是模拟时，将立即完成测试。
知道我出了什么错吗？
我的配置：
macOS Mojave 10.14.6
Spock 1.3-groovy-2
浏览 0提问于2019-09-10得票数 0
回答已采纳
我试图在某些数据库异常上实现带有重试策略的数据库查询。重试策略的代码不是很相关，所以我没有包括它。正如您在下面的代码中所看到的，我已经编写了一个retryCallable，它采用了重试策略和populateData()中的可调用策略。
在getDataFromDB中，我从DB获取数据，并将数据放在全局哈希映射中，作为应用程序级的缓存。
此代码正在按预期工作。我想从不同的类调用populateData。然而，这将是一个阻塞呼叫。因为这是数据库，并且有重试策略，这可能会很慢。我想异步调用populateData。
如何使用CompletableFuture或FutureTask来实现这一点？Com
浏览 1提问于2018-03-13得票数 5
回答已采纳
与自己直接返回CompletableFuture相比，使用有什么优势？
浏览 1提问于2017-06-22得票数 27
回答已采纳
1回答
我有下面的情景。
CompletableFuture<T> result = CompletableFuture.supplyAsync(task, executor);
result.thenRun(() -> {
...
});
// ....
// after some more code, based on some condition I attach the thenApply() to result.
if ( x == 1) {
result.thenApplyAsync(t -> {
return n
浏览 0提问于2018-06-07得票数 2
回答已采纳
我已经看过这段代码很多次了，但不知道它的优点/缺点是什么。在Spring Boot应用程序中，我看到人们定义了这个bean。
@Bean
@Qualifier("heavyLoadBean")
public ExecutorService heavyLoadBean() {
return Executors.newWorkStealingPool();
}
然后，每当在服务层中创建CompletableFuture对象时，就会使用该heavyLoadBean。
public CompletionStage<T> myService() {
return
浏览 0提问于2019-03-08得票数 5
我从Spring开始使用CompletableFuture，在一些地方我看到通常的存储库方法返回CompletableFuture <Entity>而不是Entity。
我不知道发生了什么，但是当我在存储库中返回CompletableFuture实例时，代码运行得很好。但是，当我返回实体时，代码不异步工作，并且总是返回null。
下面是一个示例：
@Service
public class AsyncServiceImpl{
/** .. Init repository instances .. **/
@Async(AsyncConfiguration.TASK
浏览 0提问于2018-04-30得票数 0
回答已采纳
我正在使用Mockito来模拟一些对象，并测试我的WebSocket消息发送服务。send方法接受一个org.springframework.web.socket.WebSocketSession和一个消息，并返回一个CompletableFuture。
在传递给CompletableFuture的CompletableFuture方法的lambda中，我验证了调用session.sendMessage()方法是否具有期望值：
WebSocketSession session = mockWebSocketSession();
TextMessage expectedMessage = new
浏览 10提问于2016-09-16得票数 2
回答已采纳
我正在设计一个带有CompletableFuture的异步调用，这是一个批处理调用，我需要一次处理多个实体。在电话结束时，我必须收集关于每个项目的处理状态的信息。
作为输入，我有一个这些实体的I数组。这是一个复杂的实体，为了将一个实体编译成一个对象，我必须放置几个DAO调用。每个DAO方法都返回CompletableFuture<PartX>。
我将那些DAO调用链接起来，因为如果其中一个片段不存在，我将无法构造一个完整的对象。下面是我的代码片段的样子：
import java.util.List;
import java.util.concurrent.CompletableFu
浏览 3提问于2017-12-22得票数 0
所以我有这个代码，我想在新的线程上运行。
让我更好地解释一下，我有两个方法，我想并行运行。
public String method1(){
ExecutorService pool = Executors.newSingleThreadExecutor();
return CompletableFuture.supplyAsync(() -> {
//...
}, pool);
}
public String method2(){
ExecutorService pool = Executors.newSingleThr
浏览 4提问于2017-12-28得票数 1
我已经有了执行数据库查询的create 3函数，然后我想得到每个结果并添加到一个对象列表中，但结果总是空的，我该如何正确地做到这一点呢？下面是我要做的： 我创建了3个CompletableFuture函数： private CompletableFuture<List<TransSalesOrderOnlyResponseDto>> findPureUnAssignedSO() {
return CompletableFuture.supplyAsync(() -> iSalesOrderMapper.entityToSOOnlyDto(iTransSa
浏览 29提问于2021-04-27得票数 0
回答已采纳
我有一个关于tomcat服务器和应用程序线程管理的问题。下面是一个示例代码：
@RequestMapping(path = "/asyncCompletable", method = RequestMethod.GET)
public CompletableFuture<String> getValueAsyncUsingCompletableFuture() {
logger.info("Request received");
CompletableFuture<String> completa
浏览 8提问于2021-05-26得票数 3
2回答
CompletableFuture在单独的线程上执行任务(使用线程池)并提供回调函数。假设我在CompletableFuture中有一个API调用。这是API调用阻塞吗？线程是否会被阻塞，直到得不到API的响应？(我知道主线程/Tomcat线程将是非阻塞的，但是执行CompletableFuture任务的线程怎么办？)
据我所知，Mono是完全非阻塞的。
请说明这一点，如果我错了，请纠正我。
浏览 0提问于2019-02-25得票数 29
回答已采纳
我对这段代码有疑问：
@Async
public CompletableFuture<String> doFoo() {
CompletableFuture<String> fooFuture = new CompletableFuture<>();
try {
String fooResult = longOp();
fooFuture.complete(fooResult);
} catch (Exception e) {
fooFuture.completeException
浏览 1提问于2017-11-17得票数 27
回答已采纳
我在一个项目中发现了以下代码：
int threadCount = 10;
CompletableFuture<?>[] futures = new CompletableFuture<?>[threadCount];
for (int i = 0; i < threadCount; i++) {
futures[i] = CompletableFuture.runAsync(() -> { process.run(queue); });
}
// Wait all futures
CompletableFuture.allOf(futures).j
浏览 7提问于2020-02-17得票数 0
我有以下方法：
@EnableAsync
@Service
Class MyService{
private String processRequest() {
log.info("Start processing request");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
log.info(&#
浏览 1提问于2020-11-06得票数 5
回答已采纳
我试图理解Java8中的CompletableFuture接口。我的当前代码是：
CompletableFuture.supplyAsync(() -> wachtwoordBijwerken(gebruikersnaam, wachtwoord))
.thenAccept(this::saveOrUpdateGebruiker)
.exceptionally(e ->
{
log.error("Fout bij het bijwerken van wachtwoord voor gebruiker: " + gebruike
浏览 1提问于2017-07-03得票数 2
回答已采纳
我正在学习并尝试将CompletableFuture应用到我的问题陈述中。我有一个我正在迭代的项目列表。
Prop是一个只有两个属性prop1和prop2的类，分别是getter和setter。
List<Prop> result = new ArrayList<>();
for ( Item item : items ) {
item.load();
Prop temp = new Prop();
// once the item is loaded, get its properties
temp.setProp
浏览 25提问于2017-07-04得票数 0
回答已采纳
2回答
我希望能够在某个方法返回String[]的情况下强制转换CompletableFuture<?>来表示CompletableFuture<String[]> 因此，我有一个来自队列的CompletableFuture<?>，我想知道如何正确地转换它，而不必总是检查我的特定情况 这是我目前所拥有的..。 CompletableFuture<?> cb = cbQueue.poll();
switch(subChannel) {
case "GetServers":
((Co
浏览 17提问于2018-12-22得票数 0
回答已采纳
我正在对数据库进行多个异步调用。我将所有这些异步调用存储在List<CompletableFuture<X>> list上。我想收集所有的结果，所以我需要等待所有这些调用完成。
一种方法是创建一个CompletableFuture.allOf(list.toArray(...))...
另一种方法是使用：list.stream.map(cf -> cf.join())...
我只是想知道，与直接等待单个CompletableFuture完成相比，创建全局CompletableFuture并等待它完成(当所有单独的CompletableFuture都完成时)是否有什
浏览 4提问于2021-10-29得票数 3
回答已采纳
我正在学习CompletableFuture API，有一个例子：
CompletableFuture.completedFuture(url)
.thenComposeAsync(this::readPage, executor)
.thenApply(this::getImageURLs)
.thenApply(this::saveFoundImages)
.....
我有一个问题:如果我调用thenComposeAsync(...)方法作为第一个方法，那
浏览 0提问于2021-01-12得票数 4
回答已采纳
我有一个使用ThreadPoolExecutor异步执行事物的程序。我在Java8中使用CompletableFutures来安排这些任务，然后让线程池中可用的线程执行它们。
我的代码如下所示：
public class ThreadTest {
public void print(String m) {
System.out.println(m);
}
public class One implements Callable<Integer> {
public Integer call() throws Excepti
浏览 1提问于2018-03-20得票数 3
回答已采纳
2回答
当将两个独立的CompletableFuture与返回第三个BiFunction的BiFunction组合时，我试图避免嵌套one。目前，使用thenCombine()并不会削减它：
// What I have
public CompletableFuture<CompletableFuture<C>> doStuff() {
CompletableFuture<A> aFuture = makeSomeA();
CompletableFuture<B> bFuture = makeSomeB();
Completabl
浏览 4提问于2017-02-13得票数 9
回答已采纳
有两种方法可以强制在给定时间后超时：
我希望他们的行为也是一样的。但是，当应用于时，这两种提供超时的方法表现得非常不同！
基本上，get()似乎做了我所期望的事情(它阻止当前线程直到所有的未来完成)，而orTimeout()的行为似乎非常奇怪(在第一个未来完成之后，它会尽快解除当前线程的阻塞)。
下面是演示我正在观察的行为的一些代码：
import org.junit.Test;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
im
浏览 4提问于2020-11-12得票数 4
3回答
假设我们有以下虚拟代码：
CompletableFuture<BigInteger> cf1 = CompletableFuture.supplyAsync(() -> BigInteger.valueOf(2L));
CompletableFuture<BigInteger> cf2 = CompletableFuture.supplyAsync(() -> BigInteger.valueOf(3L));
cf1.thenCombine(cf2, (x, y) -> x.add(y)).thenAccept(System.out::println)
浏览 4提问于2015-12-04得票数 2
回答已采纳
1回答
我使用SpringBoot1.5.x，详细地说，我使用的是@Async注释。我的问题是，我在存储库中有以下方法。
@Repository
class Repository {
@Async
CompletableFuture<String> findSomething() {
/* Some code that returns something */
}
}
然后，在服务中有以下方法，该方法调用上面的存储库。
@Service
class Service {
private Repository repository;
//
浏览 0提问于2018-03-12得票数 1
回答已采纳
在下面的代码中，调用thenRunAsync有什么区别吗？我应该直接打电话给thenRun吗？
CompletableFuture.runAsync(this::doWork , executorService)
.thenRunAsync(this::handleSuccess);
针对这些评论，详细说明:如果我要使用这段代码，
CompletableFuture.runAsync(this::doWork , executorService)
.thenRun(this::handleSuccess);
它会有什么不同的表现吗？
在这两种情况下，行为都是非阻塞的，第二个
浏览 2提问于2016-04-06得票数 9
回答已采纳
我试图使用CompletableFuture方法并行运行3个操作。现在，这3个操作返回不同的类型，因此需要分别检索数据。以下是我要做的事：
CompletableFuture<List<A>> aFuture = CompletableFuture.supplyAsync (() -> getAList());
CompletableFuture<Map<String,B> bFuture = CompletableFuture.supplyAsync (() -> getBMap());
CompletableFuture<Map&
浏览 9提问于2022-04-29得票数 2
为了减少我正在从事的一个项目中使用的技术数量，我正在尝试将一些Scala类迁移到Java。完全没有使用Scala的经验，我正在尝试转换这个方法：
private val subscriptionStore = new ConcurrentHashMap[String, Promise[PushMessage]]()
def subscribe[T](msgType: PushMessageType, callerId: String, ctx: Context)(parser: PushMessage => T): Future[T] = {
val notificationP
浏览 0提问于2017-08-03得票数 0
更具体地说，在这两段代码中，有什么区别，一个是返回void，另一个是返回CompletionStage<Void>。
在代码示例2中使用void或CompletionStage<Void>的优点是什么?在代码示例2中使用，我没有使用thenCompose中的变量x。是否有更好的编写方法？，如果我在函数doValidation中返回一个boolean并检查performTask函数中的true是否是一个更好的实践？
代码示例1:
public CompletionStage<Response> performTask(Request request) thro
浏览 1提问于2019-12-23得票数 1
回答已采纳
2回答
我的代码中有几个可完成的未来。在一个可完成的未来中，我想要另一个可完成的未来(在可完成的未来中的可完成的未来)。
public CompletableFuture<List<Employee>> buildEmployee (List<EmployeeResponse> employeeInfo) {
return supplyAsync(() -> {
Map<String, List<EmployeeReward>> rewards = rewards(employeeInfo);
浏览 4提问于2019-09-18得票数 1
2回答
它们之间的区别是什么： List<String> parra = list.parallelStream()
.map(heavyPrcessingFunction)
.collect(Collectors.toList()); 这是(除了第二个有点复杂)： List<CompletableFuture<Void>> com = list.stream()
.map(x-> CompletableFuture.runAsync(() -> heavyPrcessingFunction.apply(x)))
.co
浏览 34提问于2019-09-07得票数 2
回答已采纳
某个SDK中的函数返回给我一个CompletableFuture。一旦达到值，我如何正确地读取值。 我的代码： CompletableFuture<Web3ClientVersion> web3clientCompletableFuture;
web3clientCompletableFuture = web3jNode.web3ClientVersion().sendAsync(); sendAsync()代码(SDK中)： public CompletableFuture<T> sendAsync() {
return web3jService.send
浏览 12提问于2019-06-18得票数 0
回答已采纳
我正在阅读java8 in action，第11章(关于CompletableFutures)，这让我开始思考我公司的代码库。
Java8in action book说，如果你有像我写在下面这样的代码，你一次只会使用4个CompletableFuture(如果你有一台4核的计算机)。这意味着如果您想异步执行例如10个操作，您将首先运行前4个CompletableFuture，然后运行第二个4个，然后运行剩下的2个，因为默认的ForkJoinPool.commonPool()只提供与Runtime.getRuntime().availableProcessors()相等的线程数量。
在我公司的代
浏览 38提问于2018-06-11得票数 4
回答已采纳
我需要在现有的fat代码中创建一个服务，以从4个API中获得结果，我需要合并它们并重新格式化每个响应，但是由于4个调用，我不知道如何并发，所以非常慢。我也无法更改主以在主代码中添加Runnable或类似的执行器，因为它可能会对另一个代码产生滚雪球效应。
因此，目前，我已经制作了一个处理请求的控制器，一个从用户那里获取请求并调用5个不同服务中间件(SM)功能的服务。用于调用外部API的每个SM函数，在每个SM中，我都会重新格式化API的每个返回映射。我使用java.net.HttpURLConnection进行API调用。因此，我的API“工作”，但不能超过4秒。这些API需要额外的OAuth，
浏览 5提问于2022-01-04得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
