Java 然后在将来申请

在下面的代码中

public CompletableFuture<String> getMyFuture(String input)
    {   
        CompletableFuture<String> future = new CompletableFuture<String>().thenApply((result) -> result+ "::");
        ExecutorService service = Executors.newFixedThreadPool(6);
        service.submit(() -> {      
            try {
                future.complete(getResult(input));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        return future;
    }

    public String getResult(String input) throws InterruptedException
    {
        Thread.sleep(3000);
        return "hello "+ input +" :" + LocalTime.now();
    }

public CompletableFuture getMyFuture（字符串输入）
{   
CompletableFuture=新建CompletableFuture（）。然后应用（（结果）->result+“：”；
ExecutorService=Executors.newFixedThreadPool（6）；
服务提交（（）->{
试一试{
future.complete（获取结果（输入））；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
});
回归未来；
}
公共字符串getResult（字符串输入）引发InterruptedException
{
睡眠（3000）；
返回“hello”+input+：“+LocalTime.now（）；
}

我希望输出包含尾随“：”，但程序不是“hello first:16:49:30.231”

---

“我对apply的执行是否正确

您正在调用在第一行得到的

CompletionStage

方法的

complete（）

如果您打算使用一些字符串值（
future.complete（getResult（input））
）来完成
CompletableFuture
，然后应用一些函数，那么最好将
thenApply（）
放在末尾（返回future）

public CompletableFuture getMyFuture（字符串输入）
{
CompletableFuture=新的CompletableFuture（）；
ExecutorService=Executors.newFixedThreadPool（6）；
服务提交（（）->{
试一试{
future.complete（获取结果（输入））；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
});
返回future。然后应用（结果->结果+：”；
}

我不知道如何用更容易理解的方式来解释它。但简而言之：您在
Runnable
中对错误的对象引用调用
complete（）
方法，您正在调用在第一行得到的
CompletionStage
方法（在这里您调用“thenApply”方法）

如果您打算使用一些字符串值（
future.complete（getResult（input））
）来完成
CompletableFuture
，然后应用一些函数，那么最好将
thenApply（）
放在末尾（返回future）

public CompletableFuture getMyFuture（字符串输入）
{
CompletableFuture=新的CompletableFuture（）；
ExecutorService=Executors.newFixedThreadPool（6）；
服务提交（（）->{
试一试{
future.complete（获取结果（输入））；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
});
返回future。然后应用（结果->结果+：”；
}

我不知道如何用更容易理解的方式来解释它。但简而言之：您在
Runnable
中对错误的对象引用调用
complete（）
方法，您正在创建两个
CompletableFuture
实例。第一个是通过
newcompletablefuture（）
创建的，它永远不会完成，您甚至不保留一个引用来完成它

第二个是通过对第一个函数调用
.thenApply（（result）->result+“：：”
创建的，它可以在第一个函数完成后通过计算指定的函数来完成，并使用第一个函数的结果作为函数的参数。但是，由于第一个函数从未完成，因此该函数变得无关紧要

但是
CompletableFuture
实例可以由任何人完成，而不仅仅是传递给链接方法的函数。完成的可能性甚至在其类名中显著地显示出来。在多次完成尝试的情况下，一个将成为第一个，赢得比赛，所有后续完成尝试将被忽略。在代码中，您只有一次完成尝试，它将使用
getResult
返回的值成功完成它，而不进行任何修改

您可以将代码更改为将对第一个
CompletableFuture
实例的引用保留为
complete
手动完成，以便使用传递给
然后应用的函数完成第二个实例，但另一方面，此处不需要手动完成：

public CompletableFuture<String> getMyFuture(String input) {   
    ExecutorService service = Executors.newFixedThreadPool(6);
    return CompletableFuture.supplyAsync(() -> getResult(input), service)
                            .thenApply(result -> result + "::");
}
public String getResult(String input) {
    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(3));
    return "hello "+ input +" :" + LocalTime.now();
}    

public CompletableFuture getMyFuture（字符串输入）{
ExecutorService=Executors.newFixedThreadPool（6）；
返回CompletableFuture.SupplySync（（）->getResult（输入），服务）
。然后应用（结果->结果+“：”；
}
公共字符串getResult（字符串输入）{
锁支持。Parknos（时间单位。秒。toNanos（3））；
返回“hello”+input+：“+LocalTime.now（）；
}    

将执行器指定为
supplyAsync
时，将使用该执行器评估函数。不需要更多

不用说，这只是一个例子。您永远不应该创建临时线程池执行器，因为线程池执行器的全部目的是允许重用线程（并且您只使用这六个线程中的一个），并且在使用后它应该关闭。
您正在创建两个
CompletableFuture
实例。第一个是通过
newcompletablefuture（）
创建的，它永远不会完成，您甚至不保留一个引用来完成它

第二个是通过对第一个函数调用
.thenApply（（result）->result+“：：”
创建的，它可以在第一个函数完成后通过计算指定的函数来完成，并使用第一个函数的结果作为函数的参数。但是，由于第一个函数从未完成，因此该函数变得无关紧要

但是
CompletableFuture
实例可以由任何人完成，而不仅仅是传递给链接方法的函数。完成的可能性甚至是p
public CompletableFuture<String> getMyFuture(String input) {   
    ExecutorService service = Executors.newFixedThreadPool(6);
    return CompletableFuture.supplyAsync(() -> getResult(input), service)
                            .thenApply(result -> result + "::");
}
public String getResult(String input) {
    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(3));
    return "hello "+ input +" :" + LocalTime.now();
}