web-dev-qa-db-ja.com

ExecutorServiceを使用して、すべてのスレッドが終了するのを待つ方法は？

一度に4つのタスクを実行する必要があります。これは次のようなものです。

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
    taskExecutor.execute(new MyTask());
}
//...wait for completion somehow

すべてが完了したら通知を受けるにはどうすればいいですか？今のところ、グローバルタスクカウンタを設定してすべてのタスクの終わりにそれを減らすより良いことは何も考えられません。そして無限ループでこのカウンタが0になるまで監視します。または先物のリストを取得し、無限ループモニタでそれらすべてに対してisDoneを実行します。無限ループを含まないより良い解決策は何ですか？

ありがとう。

javamultithreadingconcurrencyparallel-processingexecutorservice
342
serg

基本的に ExecutorService では、 shutdown() を呼び出し、次に awaitTermination() を呼び出します。

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
  taskExecutor.execute(new MyTask());
}
taskExecutor.shutdown();
try {
  taskExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
  ...
}
411
cletus

CountDownLatch を使用します。

CountDownLatch latch = new CountDownLatch(totalNumberOfTasks);
ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
  taskExecutor.execute(new MyTask());
}

try {
  latch.await();
} catch (InterruptedException E) {
   // handle
}

そしてあなたの仕事の中で（try/finallyに同封）

latch.countDown();
164
ChssPly76

ExecutorService.invokeAll() はあなたのためにそれをします。

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
List<Callable<?>> tasks; // your tasks
// invokeAll() returns when all tasks are complete
List<Future<?>> futures = taskExecutor.invokeAll(tasks);
80
sjlee

先物リストも使用できます：

List<Future> futures = new ArrayList<Future>();
// now add to it:
futures.add(executorInstance.submit(new Callable<Void>() {
  public Void call() throws IOException {
     // do something
    return null;
  }
}));

次に、それらすべてに参加したい場合、基本的にそれぞれに参加するのと同等です（子スレッドからメインに例外を再発生させるという追加の利点があります）：

for(Future f: this.futures) { f.get(); }

基本的に、トリックは、（すべてまたは各）でisDone（）を呼び出す無限ループの代わりに、各Futureで.get（）を呼び出すことです。したがって、最後のスレッドが終了するとすぐに、このブロックを「先に進む」ことができます。警告は、.get（）呼び出しが例外を再発生させるため、スレッドの1つが停止した場合、他のスレッドが完了するまでにこれから発生する可能性があることです[これを回避するには、catch ExecutionException get呼び出しの周り]。もう1つの注意点は、すべてのスレッドへの参照を保持しているため、スレッドローカル変数がある場合、このブロックを通過するまで収集されません（問題が発生した場合、削除することでこれを回避できる可能性があります） FutureはArrayListから外れています）。どのFutureが「最初に終了」するかを知りたい場合は、 https://stackoverflow.com/a/31885029/3245 のようなものを使用できます。

43
rogerdpack

Java 8では、 CompletableFuture を使って実行できます。

ExecutorService es = Executors.newFixedThreadPool(4);
List<Runnable> tasks = getTasks();
CompletableFuture<?>[] futures = tasks.stream()
                               .map(task -> CompletableFuture.runAsync(task, es))
                               .toArray(CompletableFuture[]::new);
CompletableFuture.allOf(futures).join();    
es.shutdown();
28
AdamSkywalker

たった2セントです。 CountDownLatchが事前にタスクの数を知っておくという要件を克服するためには、単純なSemaphoreを使用することによって古い方法でそれを行うことができます。

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
int numberOfTasks=0;
Semaphore s=new Semaphore(0);
while(...) {
    taskExecutor.execute(new MyTask());
    numberOfTasks++;
}

try {
    s.aquire(numberOfTasks);
...

あなたのタスクではs.release()と同じようにlatch.countDown();を呼び出してください。

24
stryba

Java 5以降の CyclicBarrier クラスはこのようなことのために設計されています。

12
Pekka Enberg

ちょっとゲームに遅れるが、完成のために...

すべてのタスクが完了するのを「待つ」のではなく、「私に電話をかけないでください、私はあなたに電話します」というハリウッドの原則から考えることができます。結果のコードはもっとエレガントだと思います...

グアバはこれを達成するためのいくつかの興味深いツールを提供しています。

例 ：：

ExecutorServiceをListeningExecutorServiceにラップする::

ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));

実行のために呼び出し可能オブジェクトのコレクションを送信する::

for (Callable<Integer> callable : callables) {
  ListenableFuture<Integer> lf = service.submit(callable);
  // listenableFutures is a collection
  listenableFutures.add(lf)
});

今不可欠な部分：

ListenableFuture<List<Integer>> lf = Futures.successfulAsList(listenableFutures);

ListenableFutureにコールバックを添付します。これは、すべての未来が完了したときに通知を受けるために使用できます。

        Futures.addCallback(lf, new FutureCallback<List<Integer>>() {
        @Override
        public void onSuccess(List<Integer> result) {
            log.info("@@ finished processing {} elements", Iterables.size(result));
            // do something with all the results
        }

        @Override
        public void onFailure(Throwable t) {
            log.info("@@ failed because of :: {}", t);
        }
    });

これはまた、処理が終了した後に一箇所にすべての結果を収集できるという利点もあります。

詳しい情報 はこちら

12
Răzvan Petruescu

以下のいずれかの方法に従ってください。

  1. submitのExecutorServiceから返されるすべての 将来 のタスクを繰り返し、FutureオブジェクトでKiranオブジェクトのブロック呼び出しget()を使ってステータスをチェックします。
  2. ExecutorService でinvokeAll()を使用する
  3. CountDownLatch
  4. ForkJoinPool または Executors.html＃newWorkStealingPool
  5. ThreadPoolExecutorのshutdown, awaitTermination, shutdownNow APIを正しい順序で使用する

関連するSEの質問：

JavaマルチスレッドでCountDownLatchはどのように使用されますか？

Java ExecutorServiceを正しくシャットダウンする方法

7
Ravindra babu

これには2つの選択肢がありますが、どちらを選択するのが良いのか少し混乱します。

オプション1：

ExecutorService es = Executors.newFixedThreadPool(4);
List<Runnable> tasks = getTasks();
CompletableFuture<?>[] futures = tasks.stream()
                               .map(task -> CompletableFuture.runAsync(task, es))
                               .toArray(CompletableFuture[]::new);
CompletableFuture.allOf(futures).join();    
es.shutdown();

オプション2：

ExecutorService es = Executors.newFixedThreadPool(4);
List< Future<?>> futures = new ArrayList<>();
for(Runnable task : taskList) {
    futures.add(es.submit(task));
}

for(Future<?> future : futures) {
    try {
        future.get();
    }catch(Exception e){
        // do logging and nothing else
    }
}
es.shutdown();

ここにfuture.get（）を入れます。トライキャッチで良い考えは正しいですか？

5
user2862544

タスクを別のランナブルにラップして通知を送信することもできます。

taskExecutor.execute(new Runnable() {
  public void run() {
    taskStartedNotification();
    new MyTask().run();
    taskFinishedNotification();
  }
});
5
Zed

ここでは、ラッチ/バリアを使用することとは異なる、より多くの選択肢を提供するためだけに使用します。それらすべてが CompletionService を使って終了するまで部分的な結果を得ることもできます。

実際にはJava Concurrencyから： "Executorに送信する計算のバッチがあり、それらが利用可能になったときに結果を取得したい場合は、各タスクに関連するFutureを保持し、get withゼロのタイムアウトこれは可能です、しかし退屈な。幸いなことによりよい方法があります：完了サービス。 "

ここでの実装

public class TaskSubmiter {
    private final ExecutorService executor;
    TaskSubmiter(ExecutorService executor) { this.executor = executor; }
    void doSomethingLarge(AnySourceClass source) {
        final List<InterestedResult> info = doPartialAsyncProcess(source);
        CompletionService<PartialResult> completionService = new ExecutorCompletionService<PartialResult>(executor);
        for (final InterestedResult interestedResultItem : info)
            completionService.submit(new Callable<PartialResult>() {
                public PartialResult call() {
                    return InterestedResult.doAnOperationToGetPartialResult();
                }
        });

    try {
        for (int t = 0, n = info.size(); t < n; t++) {
            Future<PartialResult> f = completionService.take();
            PartialResult PartialResult = f.get();
            processThisSegment(PartialResult);
            }
        } 
        catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } 
        catch (ExecutionException e) {
            throw somethinghrowable(e.getCause());
        }
    }
}
3
Alberto Gurrion

私はあなたの問題を解決するサンプルプログラムを書きました。簡潔な実装はありませんので、追加します。 executor.shutdown()とexecutor.awaitTermination()を使用することはできますが、異なるスレッドが費やす時間は予測できないため、ベストプラクティスではありません。

ExecutorService es = Executors.newCachedThreadPool();
    List<Callable<Integer>> tasks = new ArrayList<>();

    for (int j = 1; j <= 10; j++) {
        tasks.add(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                int sum = 0;
                System.out.println("Starting Thread "
                        + Thread.currentThread().getId());

                for (int i = 0; i < 1000000; i++) {
                    sum += i;
                }

                System.out.println("Stopping Thread "
                        + Thread.currentThread().getId());
                return sum;
            }

        });
    }

    try {
        List<Future<Integer>> futures = es.invokeAll(tasks);
        int flag = 0;

        for (Future<Integer> f : futures) {
            Integer res = f.get();
            System.out.println("Sum: " + res);
            if (!f.isDone()) 
                flag = 1;
        }

        if (flag == 0)
            System.out.println("SUCCESS");
        else
            System.out.println("FAILED");

    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
3
Kiran

これは "AdamSkywalker"のヒントに基づいた私の解決策であり、それは機能します

package frss.main;

import Java.util.ArrayList;
import Java.util.List;
import Java.util.concurrent.CompletableFuture;
import Java.util.concurrent.ExecutorService;
import Java.util.concurrent.Executors;

public class TestHilos {

    void procesar() {
        ExecutorService es = Executors.newFixedThreadPool(4);
        List<Runnable> tasks = getTasks();
        CompletableFuture<?>[] futures = tasks.stream().map(task -> CompletableFuture.runAsync(task, es)).toArray(CompletableFuture[]::new);
        CompletableFuture.allOf(futures).join();
        es.shutdown();

        System.out.println("FIN DEL PROCESO DE HILOS");
    }

    private List<Runnable> getTasks() {
        List<Runnable> tasks = new ArrayList<Runnable>();

        Hilo01 task1 = new Hilo01();
        tasks.add(task1);

        Hilo02 task2 = new Hilo02();
        tasks.add(task2);
        return tasks;
    }

    private class Hilo01 extends Thread {

        @Override
        public void run() {
            System.out.println("HILO 1");
        }

    }

    private class Hilo02 extends Thread {

        @Override
        public void run() {
            try {
                sleep(2000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("HILO 2");
        }

    }


    public static void main(String[] args) {
        TestHilos test = new TestHilos();
        test.procesar();
    }
}
2
frss-soft.com

このコードを使うことができます：

public class MyTask implements Runnable {

    private CountDownLatch countDownLatch;

    public MyTask(CountDownLatch countDownLatch {
         this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
         try {
             //Do somethings
             //
             this.countDownLatch.countDown();//important
         } catch (InterruptedException ex) {
              Thread.currentThread().interrupt();
         }
     }
}

CountDownLatch countDownLatch = new CountDownLatch(NUMBER_OF_TASKS);
ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
for (int i = 0; i < NUMBER_OF_TASKS; i++){
     taskExecutor.execute(new MyTask(countDownLatch));
}
countDownLatch.await();
System.out.println("Finish tasks");
2
Tuan Pham

Java 8 - ストリームを処理するためにストリームAPIを使用できます。下のスニペットを見てください

final List<Runnable> tasks = ...; //or any other functional interface
tasks.stream().parallel().forEach(Runnable::run) // Uses default pool

//alternatively to specify parallelism 
new ForkJoinPool(15).submit(
          () -> tasks.stream().parallel().forEach(Runnable::run) 
    ).get();
1
Vlad

executorService.shutdown()とexecutorService.awaitTerminationメソッドを使うべきです。

次のような例です。

public class ScheduledThreadPoolExample {

    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        executorService.scheduleAtFixedRate(() -> System.out.println("process task."),
                0, 1, TimeUnit.SECONDS);

        TimeUnit.SECONDS.sleep(10);
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);
    }

}
1
Rollen Holt

だから私はここにリンクされた質問から私の答えを投稿します。

ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture[] futures = new CompletableFuture[10];
int i = 0;
while (...) {
    futures[i++] =  CompletableFuture.runAsync(runner, executor);
}

CompletableFuture.allOf(futures).join(); // THis will wait until all future ready.
1
Mạnh Quyết Nguyễn

taskExecutorをラップするために ExecutorCompletionService の独自のサブクラスを使用し、各タスクが完了したときに通知を受けるために BlockingQueue を独自に実装することができます。完了したタスクの数が目的の目標に達したら、必要なコールバックまたはその他のアクションを実行します。

1
Alex Martelli

私は以下の作業例を作成しました。アイデアは、（例としてキューを使用している）多数のスレッドを持つタスクのプール（numberOfTasks/thresholdによってプログラム的に決定される）を処理し、他の処理を続けるためにすべてのスレッドが完了するまで待つ方法です。

import Java.util.PriorityQueue;
import Java.util.Queue;
import Java.util.concurrent.CountDownLatch;
import Java.util.concurrent.ExecutorService;
import Java.util.concurrent.Executors;

/** Testing CountDownLatch and ExecutorService to manage scenario where
 * multiple Threads work together to complete tasks from a single
 * resource provider, so the processing can be faster. */
public class ThreadCountDown {

private CountDownLatch threadsCountdown = null;
private static Queue<Integer> tasks = new PriorityQueue<>();

public static void main(String[] args) {
    // Create a queue with "Tasks"
    int numberOfTasks = 2000;
    while(numberOfTasks-- > 0) {
        tasks.add(numberOfTasks);
    }

    // Initiate Processing of Tasks
    ThreadCountDown main = new ThreadCountDown();
    main.process(tasks);
}

/* Receiving the Tasks to process, and creating multiple Threads
* to process in parallel. */
private void process(Queue<Integer> tasks) {
    int numberOfThreads = getNumberOfThreadsRequired(tasks.size());
    threadsCountdown = new CountDownLatch(numberOfThreads);
    ExecutorService threadExecutor = Executors.newFixedThreadPool(numberOfThreads);

    //Initialize each Thread
    while(numberOfThreads-- > 0) {
        System.out.println("Initializing Thread: "+numberOfThreads);
        threadExecutor.execute(new MyThread("Thread "+numberOfThreads));
    }

    try {
        //Shutdown the Executor, so it cannot receive more Threads.
        threadExecutor.shutdown();
        threadsCountdown.await();
        System.out.println("ALL THREADS COMPLETED!");
        //continue With Some Other Process Here
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    }
}

/* Determine the number of Threads to create */
private int getNumberOfThreadsRequired(int size) {
    int threshold = 100;
    int threads = size / threshold;
    if( size > (threads*threshold) ){
        threads++;
    }
    return threads;
}

/* Task Provider. All Threads will get their task from here */
private synchronized static Integer getTask(){
    return tasks.poll();
}

/* The Threads will get Tasks and process them, while still available.
* When no more tasks available, the thread will complete and reduce the threadsCountdown */
private class MyThread implements Runnable {

    private String threadName;

    protected MyThread(String threadName) {
        super();
        this.threadName = threadName;
    }

    @Override
    public void run() {
        Integer task;
        try{
            //Check in the Task pool if anything pending to process
            while( (task = getTask()) != null ){
                processTask(task);
            }
        }catch (Exception ex){
            ex.printStackTrace();
        }finally {
            /*Reduce count when no more tasks to process. Eventually all
            Threads will end-up here, reducing the count to 0, allowing
            the flow to continue after threadsCountdown.await(); */
            threadsCountdown.countDown();
        }
    }

    private void processTask(Integer task){
        try{
            System.out.println(this.threadName+" is Working on Task: "+ task);
        }catch (Exception ex){
            ex.printStackTrace();
        }
    }
}
}

それが役に立てば幸い！

1
Fernando Gil

ExecutorService WORKER_THREAD_POOL 
  = Executors.newFixedThreadPool(10);
CountDownLatch latch = new CountDownLatch(2);
for (int i = 0; i < 2; i++) {
    WORKER_THREAD_POOL.submit(() -> {
        try {
            // doSomething();
            latch.countDown();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });
}

// wait for the latch to be decremented by the two remaining threads
latch.await();

doSomething()が他の例外を投げた場合、latch.countDown()は実行されないようですので、どうしたらいいですか？

0
Pengfei Zhan