Java 并行执行竞争计算，并丢弃除第一个完成的计算外的所有计算

我编写了一个基于随机性生成迷宫的函数。大多数情况下，此功能非常快。但偶尔，由于随机数带来的坏运气，这需要几秒钟的时间

我想同时启动这个函数多次，让最快的函数“赢”

---

Scala标准库（或Java标准库）是否为这项工作提供了合适的工具？

您可以使用

Future

：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

val futures = for (_ <- 1 to 4) yield Future { /* computation */ }
val resultFuture = Future.firstCompletedOf(futures)

public class FirstDoneWithCompletableFutureEx {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        int jobs = 10;
        CompletableFuture<?>[] futures = new CompletableFuture[jobs];
        for (int i = 0; i < jobs; i++) {
            futures[i] = CompletableFuture.supplyAsync(() -> {
                //computation    
                return new Object();
            });
        }

        //first job done
        Object firstDone = CompletableFuture.anyOf(futures).get();
    }
}

---

具有

CompletableFuture

的java 8解决方案：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

val futures = for (_ <- 1 to 4) yield Future { /* computation */ }
val resultFuture = Future.firstCompletedOf(futures)

public class FirstDoneWithCompletableFutureEx {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        int jobs = 10;
        CompletableFuture<?>[] futures = new CompletableFuture[jobs];
        for (int i = 0; i < jobs; i++) {
            futures[i] = CompletableFuture.supplyAsync(() -> {
                //computation    
                return new Object();
            });
        }

        //first job done
        Object firstDone = CompletableFuture.anyOf(futures).get();
    }
}

---

也许更容易（也更有效）找到为什么程序有时需要几秒钟的时间来修复它…你可能想要，但我同意@immibis@immibis迷宫式的一代（没有死胡同）似乎只是一个难题，我发现/能想到的每一个解决方案都需要大量的回溯。这听起来是一个完美的机会，可以将CompletableFuture与AcceptOrther CompletionStage一起使用。有没有一种简单的方法可以在第一次计算完成时取消挂起的计算？@FredOverflow看到这个问题：