並行執行競爭性計算並丟棄除第一個完成的所有條目外

Question

我編寫了一個基於隨機性生成迷宮的函數。大多數情況下，這個功能非常快。但每隔一段時間，由於隨機數字運氣不好，需要幾秒鐘的時間。

我想多次平行啓動這個函數，讓最快的函數「win」。

Scala標準庫（或Java標準庫）是否爲這項工作提供了合適的工具？

Answer 1

一個java 8溶液CompletableFuture：

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(); 
    } 
} 

java 5,6,7解決方案CompletionService：

public class FirstDoneWithCompletionServiceEx { 

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

     int jobs = 10; 
     ExecutorService executorService = Executors.newFixedThreadPool(jobs); 
     CompletionService<Object> completionService = new ExecutorCompletionService<>(executorService); 

     for (int i = 0; i < jobs; i++) 
      completionService.submit(
        new Callable<Object>() { 
         @Override 
         public Object call() throws Exception { 
          //computation 
          return new Object(); 
         } 
        } 
      ); 

     //get first job done 
     Object firstDone = completionService.take().get(); 

     executorService.shutdownNow(); 
    } 
} 

Answer 2

您可以使用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) 

如果你想阻止（我想你這樣做），你可以使用Await.result：

import scala.concurrent.Await 
import scala.concurrent.duration.Duration 

val result = Await.result(resultFuture, Duration.Inf)