未来のリストを待っています


145

List先物を返すメソッドがあります

List<Future<O>> futures = getFutures();

ここで、すべてのフューチャーが正常に処理されるか、フューチャーによって出力が返されるタスクのいずれかが例外をスローするまで待機します。1つのタスクが例外をスローしたとしても、他のフューチャーを待つ意味はありません。

単純なアプローチは

wait() {

   For(Future f : futures) {
     try {
       f.get();
     } catch(Exception e) {
       //TODO catch specific exception
       // this future threw exception , means somone could not do its task
       return;
     }
   }
}

ただし、ここでの問題は、たとえば、4番目のフューチャーが例外をスローした場合、最初の3つのフューチャーが使用可能になるまで不必要に待機します。

これを解決するには?カウントダウンラッチは何らかの形で役立ちますか?isDonejava docが言っているので、Futureを使用できません。

boolean isDone()
Returns true if this task completed. Completion may be due to normal termination, an exception, or cancellation -- in all of these cases, this method will return true.

1
誰がそれらの先物を生み出すのですか?彼らはどんなタイプですか?インターフェースjava.util.concurrent.Futureは、必要な機能を提供しません。唯一の方法は、コールバックで独自のFutureを使用することです。
アレクセイカイゴロドフ2013年

ExecutionServiceタスクの「バッチ」ごとにのインスタンスを作成し、それに送信してから、すぐにサービスをシャットダウンして使用awaitTermination()するとします。
ミリムース

CountDownLatchすべてのフューチャーのボディをaでラップした場合は、a try..finallyを使用して、ラッチも確実にデクリメントされるようにすることができます。
ミリムース

docs.oracle.com/javase/7/docs/api/java/util/concurrent/…は、まさに必要なことを行います。
assylias 2013年

@AlexeiKaigorodovはい、私の将来のタイプはjava.util.concurrentです。callableで将来を訴えています。execureserviceにタスクを送信すると、Futtureが表示されます
user93796

回答:


124

CompletionServiceを使用して、フューチャーの準備ができ次第、フューチャーの1つが例外をスローした場合、処理をキャンセルできます。このようなもの:

Executor executor = Executors.newFixedThreadPool(4);
CompletionService<SomeResult> completionService = 
       new ExecutorCompletionService<SomeResult>(executor);

//4 tasks
for(int i = 0; i < 4; i++) {
   completionService.submit(new Callable<SomeResult>() {
       public SomeResult call() {
           ...
           return result;
       }
   });
}

int received = 0;
boolean errors = false;

while(received < 4 && !errors) {
      Future<SomeResult> resultFuture = completionService.take(); //blocks if none available
      try {
         SomeResult result = resultFuture.get();
         received ++;
         ... // do something with the result
      }
      catch(Exception e) {
             //log
         errors = true;
      }
}

タスクの1つがエラーをスローした場合、まだ実行中のタスクをキャンセルするようにさらに改善できると思います。


1
:あなたのコードには私の投稿で述べたのと同じ問題があります.4番目のフューチャーが例外をスローした場合、コードはフューチャー1、2、3が完了するまで待機します。またはcompletionSerice.take)は、最初に完了する未来を返しますか?
user93796 2013年

1
タイムアウトについてはどうですか?完了サービスに最大でX秒待機するように指示できますか?
user93796 2013年

1
持つべきではない。これは先物を反復しませんが、準備ができるとすぐに、例外がスローされない場合は処理/検証されます。
dcernahoschi 2013年

2
キューにフューチャーが現れるのを待ってタイムアウトするために、にpoll(seconds)メソッドがありCompletionServiceます。
dcernahoschi 2013年

以下はgithubでの作業例です:github.com/princegoyal1987/FutureDemo
user18853

107

Java 8を使用している場合、CompletableFutureとCompletableFuture.allOfを使用すると、これを簡単に行うことができます。これにより、提供されたすべてのCompletableFutureが完了した後でのみコールバックが適用されます。

// Waits for *all* futures to complete and returns a list of results.
// If *any* future completes exceptionally then the resulting future will also complete exceptionally.

public static <T> CompletableFuture<List<T>> all(List<CompletableFuture<T>> futures) {
    CompletableFuture[] cfs = futures.toArray(new CompletableFuture[futures.size()]);

    return CompletableFuture.allOf(cfs)
            .thenApply(ignored -> futures.stream()
                                    .map(CompletableFuture::join)
                                    .collect(Collectors.toList())
            );
}

3
こんにちは@Andrejs、このコードスニペットの機能を説明してください。これは複数の場所で提案されていますが、実際に何が起こっているのか混乱しています。スレッドの1つが失敗した場合、例外はどのように処理されますか?
VSEWHGHP 2017年

2
@VSEWHGHP javadocから:指定されたCompletableFutureのいずれかが例外的に完了した場合、返されたCompletableFutureも完了し、CompletionExceptionがこの例外を原因として保持します。
Andrejs

1
私がフォローアップしていたので、このスニペットを使用する方法はありますが、正常に完了した他のすべてのスレッドの値を取得しますか?シーケンス関数はすべてのスレッドが結果または例外のいずれかで完了することを保証するので、CompletableFuturesリストを反復処理してgetを呼び出してCompletableFuture <List <T >>を無視するだけでよいですか?
VSEWHGHP 2017年

6
これは別の問題を解決しています。Futureインスタンスがある場合、このメソッドを適用することはできません。これは、変換するのは簡単ではありませんFutureCompletableFuture
Jarekczek、2018年

一部のタスクで例外がある場合は機能しません。
slisnychyi

21

CompletableFutureJava 8でを使用する

    // Kick of multiple, asynchronous lookups
    CompletableFuture<User> page1 = gitHubLookupService.findUser("Test1");
    CompletableFuture<User> page2 = gitHubLookupService.findUser("Test2");
    CompletableFuture<User> page3 = gitHubLookupService.findUser("Test3");

    // Wait until they are all done
    CompletableFuture.allOf(page1,page2,page3).join();

    logger.info("--> " + page1.get());

1
これは受け入れられる答えになるはずです。また、公式のSpringドキュメントの一部です: spring.io/guides/gs/async-method
maaw

期待どおりに動作します。
ダイモン

15

ExecutorCompletionServiceを使用できます。ドキュメントには、正確なユースケースの例も含まれています。

代わりに、一連のタスクの最初のnull以外の結果を使用して、例外が発生したものをすべて無視し、最初のタスクの準備ができたときに他のすべてのタスクをキャンセルするとします。

void solve(Executor e, Collection<Callable<Result>> solvers) throws InterruptedException {
    CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
    int n = solvers.size();
    List<Future<Result>> futures = new ArrayList<Future<Result>>(n);
    Result result = null;
    try {
        for (Callable<Result> s : solvers)
            futures.add(ecs.submit(s));
        for (int i = 0; i < n; ++i) {
            try {
                Result r = ecs.take().get();
                if (r != null) {
                    result = r;
                    break;
                }
            } catch (ExecutionException ignore) {
            }
        }
    } finally {
        for (Future<Result> f : futures)
            f.cancel(true);
    }

    if (result != null)
        use(result);
}

ここで注意すべき重要な点は、ecs.take()が最初に送信されたタスクだけでなく、最初に完了したタスクを取得することです。したがって、実行を完了する(または例外をスローする)順序でそれらを取得する必要があります。


3

Java 8を使用していてCompletableFuture、s を操作したくない場合は、List<Future<T>>ストリーミングを使用して結果を取得するツールを作成しました。重要なのは、map(Future::get)投げるのが禁止されていることです。

public final class Futures
{

    private Futures()
    {}

    public static <E> Collector<Future<E>, Collection<E>, List<E>> present()
    {
        return new FutureCollector<>();
    }

    private static class FutureCollector<T> implements Collector<Future<T>, Collection<T>, List<T>>
    {
        private final List<Throwable> exceptions = new LinkedList<>();

        @Override
        public Supplier<Collection<T>> supplier()
        {
            return LinkedList::new;
        }

        @Override
        public BiConsumer<Collection<T>, Future<T>> accumulator()
        {
            return (r, f) -> {
                try
                {
                    r.add(f.get());
                }
                catch (InterruptedException e)
                {}
                catch (ExecutionException e)
                {
                    exceptions.add(e.getCause());
                }
            };
        }

        @Override
        public BinaryOperator<Collection<T>> combiner()
        {
            return (l1, l2) -> {
                l1.addAll(l2);
                return l1;
            };
        }

        @Override
        public Function<Collection<T>, List<T>> finisher()
        {
            return l -> {

                List<T> ret = new ArrayList<>(l);
                if (!exceptions.isEmpty())
                    throw new AggregateException(exceptions, ret);

                return ret;
            };

        }

        @Override
        public Set<java.util.stream.Collector.Characteristics> characteristics()
        {
            return java.util.Collections.emptySet();
        }
    }

これにはAggregateExceptionC#のように機能するが必要です

public class AggregateException extends RuntimeException
{
    /**
     *
     */
    private static final long serialVersionUID = -4477649337710077094L;

    private final List<Throwable> causes;
    private List<?> successfulElements;

    public AggregateException(List<Throwable> causes, List<?> l)
    {
        this.causes = causes;
        successfulElements = l;
    }

    public AggregateException(List<Throwable> causes)
    {
        this.causes = causes;
    }

    @Override
    public synchronized Throwable getCause()
    {
        return this;
    }

    public List<Throwable> getCauses()
    {
        return causes;
    }

    public List<?> getSuccessfulElements()
    {
        return successfulElements;
    }

    public void setSuccessfulElements(List<?> successfulElements)
    {
        this.successfulElements = successfulElements;
    }

}

このコンポーネントは、C#のTask.WaitAllとまったく同じように機能します。CompletableFuture.allOf(と同等のバリアントに取り組んでいますTask.WhenAll

私がこれを行った理由は、Springを使用ListenableFutureしていてCompletableFuture、より標準的な方法であるにもかかわらず移植したくないためです。


1
同等のAggregateExceptionの必要性を確認するための賛成票。
granadaCoder

この機能の使用例がいいでしょう。
XDS

1

CompletableFuturesのリストを組み合わせる場合は、次のようにします。

List<CompletableFuture<Void>> futures = new ArrayList<>();
// ... Add futures to this ArrayList of CompletableFutures

// CompletableFuture.allOf() method demand a variadic arguments
// You can use this syntax to pass a List instead
CompletableFuture<Void> allFutures = CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[futures.size()]));

// Wait for all individual CompletableFuture to complete
// All individual CompletableFutures are executed in parallel
allFutures.get();

フューチャー&CompletableFutureの詳細については、便利なリンクの場合:
1.未来:https://www.baeldung.com/java-future
2. CompletableFuture:https://www.baeldung.com/java-completablefuture
3. CompletableFuture:HTTPS ://www.callicoder.com/java-8-completablefuture-tutorial/


0

多分これは役立つでしょう(生スレッドで置き換えられるものはありません、ええ!)私は各人Futureを個別のスレッドで実行することをお勧めします(それらは並列になります)、そしてエラーが発生したときはいつでも、manager(Handlerクラス)にシグナルを送るだけです。

class Handler{
//...
private Thread thisThread;
private boolean failed=false;
private Thread[] trds;
public void waitFor(){
  thisThread=Thread.currentThread();
  List<Future<Object>> futures = getFutures();
  trds=new Thread[futures.size()];
  for (int i = 0; i < trds.length; i++) {
    RunTask rt=new RunTask(futures.get(i), this);
    trds[i]=new Thread(rt);
  }
  synchronized (this) {
    for(Thread tx:trds){
      tx.start();
    }  
  }
  for(Thread tx:trds){
    try {tx.join();
    } catch (InterruptedException e) {
      System.out.println("Job failed!");break;
    }
  }if(!failed){System.out.println("Job Done");}
}

private List<Future<Object>> getFutures() {
  return null;
}

public synchronized void cancelOther(){if(failed){return;}
  failed=true;
  for(Thread tx:trds){
    tx.stop();//Deprecated but works here like a boss
  }thisThread.interrupt();
}
//...
}
class RunTask implements Runnable{
private Future f;private Handler h;
public RunTask(Future f,Handler h){this.f=f;this.h=h;}
public void run(){
try{
f.get();//beware about state of working, the stop() method throws ThreadDeath Error at any thread state (unless it blocked by some operation)
}catch(Exception e){System.out.println("Error, stopping other guys...");h.cancelOther();}
catch(Throwable t){System.out.println("Oops, some other guy has stopped working...");}
}
}

上記のコードはエラーになる(チェックしなかった)と言わざるを得ませんが、解決策を説明できればと思います。ぜひお試しください。


0
 /**
     * execute suppliers as future tasks then wait / join for getting results
     * @param functors a supplier(s) to execute
     * @return a list of results
     */
    private List getResultsInFuture(Supplier<?>... functors) {
        CompletableFuture[] futures = stream(functors)
                .map(CompletableFuture::supplyAsync)
                .collect(Collectors.toList())
                .toArray(new CompletableFuture[functors.length]);
        CompletableFuture.allOf(futures).join();
        return stream(futures).map(a-> {
            try {
                return a.get();
            } catch (InterruptedException | ExecutionException e) {
                //logger.error("an error occurred during runtime execution a function",e);
                return null;
            }
        }).collect(Collectors.toList());
    };

0

CompletionServiceは.submit()メソッドで呼び出し可能オブジェクトを取得し、計算された先物を.take()メソッドで取得できます。

忘れてはならないことの1つは、.shutdown()メソッドを呼び出してExecutorServiceを終了することです。また、executorサービスへの参照を保存した場合にのみこのメソッドを呼び出すことができるため、参照を保持するようにしてください。

コード例-並行して作業する固定数の作業項目の場合:

ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

CompletionService<YourCallableImplementor> completionService = 
new ExecutorCompletionService<YourCallableImplementor>(service);

ArrayList<Future<YourCallableImplementor>> futures = new ArrayList<Future<YourCallableImplementor>>();

for (String computeMe : elementsToCompute) {
    futures.add(completionService.submit(new YourCallableImplementor(computeMe)));
}
//now retrieve the futures after computation (auto wait for it)
int received = 0;

while(received < elementsToCompute.size()) {
 Future<YourCallableImplementor> resultFuture = completionService.take(); 
 YourCallableImplementor result = resultFuture.get();
 received ++;
}
//important: shutdown your ExecutorService
service.shutdown();

コード例-並行して作業する動的な数の作業項目の場合:

public void runIt(){
    ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    CompletionService<CallableImplementor> completionService = new ExecutorCompletionService<CallableImplementor>(service);
    ArrayList<Future<CallableImplementor>> futures = new ArrayList<Future<CallableImplementor>>();

    //Initial workload is 8 threads
    for (int i = 0; i < 9; i++) {
        futures.add(completionService.submit(write.new CallableImplementor()));             
    }
    boolean finished = false;
    while (!finished) {
        try {
            Future<CallableImplementor> resultFuture;
            resultFuture = completionService.take();
            CallableImplementor result = resultFuture.get();
            finished = doSomethingWith(result.getResult());
            result.setResult(null);
            result = null;
            resultFuture = null;
            //After work package has been finished create new work package and add it to futures
            futures.add(completionService.submit(write.new CallableImplementor()));
        } catch (InterruptedException | ExecutionException e) {
            //handle interrupted and assert correct thread / work packet count              
        } 
    }

    //important: shutdown your ExecutorService
    service.shutdown();
}

public class CallableImplementor implements Callable{
    boolean result;

    @Override
    public CallableImplementor call() throws Exception {
        //business logic goes here
        return this;
    }

    public boolean getResult() {
        return result;
    }

    public void setResult(boolean result) {
        this.result = result;
    }
}

0

これらを含むユーティリティクラスがあります。

@FunctionalInterface
public interface CheckedSupplier<X> {
  X get() throws Throwable;
}

public static <X> Supplier<X> uncheckedSupplier(final CheckedSupplier<X> supplier) {
    return () -> {
        try {
            return supplier.get();
        } catch (final Throwable checkedException) {
            throw new IllegalStateException(checkedException);
        }
    };
}

それができたら、静的インポートを使用して、次のようにすべての先物を待つだけです。

futures.stream().forEach(future -> uncheckedSupplier(future::get).get());

次のようにして、すべての結果を収集することもできます。

List<MyResultType> results = futures.stream()
    .map(future -> uncheckedSupplier(future::get).get())
    .collect(Collectors.toList());

私の古い投稿をもう一度見て、別の悲しみがあったことに気づいてください:

ただし、ここでの問題は、たとえば、4番目のフューチャーが例外をスローした場合、最初の3つのフューチャーが使用可能になるまで不必要に待機します。

この場合、簡単な解決策はこれを並行して行うことです:

futures.stream().parallel()
 .forEach(future -> uncheckedSupplier(future::get).get());

この方法では、最初の例外は将来を停止しませんが、シリアルの例のようにforEach-statementを壊しますが、すべてが並行して待機するため、最初の3つが完了するのを待つ必要はありません。


0
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Stack2 {   
    public static void waitFor(List<Future<?>> futures) {
        List<Future<?>> futureCopies = new ArrayList<Future<?>>(futures);//contains features for which status has not been completed
        while (!futureCopies.isEmpty()) {//worst case :all task worked without exception, then this method should wait for all tasks
            Iterator<Future<?>> futureCopiesIterator = futureCopies.iterator();
            while (futureCopiesIterator.hasNext()) {
                Future<?> future = futureCopiesIterator.next();
                if (future.isDone()) {//already done
                    futureCopiesIterator.remove();
                    try {
                        future.get();// no longer waiting
                    } catch (InterruptedException e) {
                        //ignore
                        //only happen when current Thread interrupted
                    } catch (ExecutionException e) {
                        Throwable throwable = e.getCause();// real cause of exception
                        futureCopies.forEach(f -> f.cancel(true));//cancel other tasks that not completed
                        return;
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        Runnable runnable1 = new Runnable (){
            public void run(){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                }
            }
        };
        Runnable runnable2 = new Runnable (){
            public void run(){
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                }
            }
        };


        Runnable fail = new Runnable (){
            public void run(){
                try {
                    Thread.sleep(1000);
                    throw new RuntimeException("bla bla bla");
                } catch (InterruptedException e) {
                }
            }
        };

        List<Future<?>> futures = Stream.of(runnable1,fail,runnable2)
                .map(executorService::submit)
                .collect(Collectors.toList());

        double start = System.nanoTime();
        waitFor(futures);
        double end = (System.nanoTime()-start)/1e9;
        System.out.println(end +" seconds");

    }
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.