Czekaj na wykonanie wielu funkcji AsyncTask

Question

Równoległe działanie jest wykonywane przez podzielenie go na dokładną liczbę dostępnych rdzeni, a następnie uruchomienie tego samego numeru AsyncTask, wykonanie tej samej operacji, ale na różnych częściach danych.

Używam executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ...) w celu zrównoleglenia ich wykonania.

Chciałbym wiedzieć, kiedy każdy wątek kończy swoją pracę, aby połączyć wszystkie wyniki i wykonać dalsze operacje.

Jak mogę to zrobić?

Answer 1

Można też po prostu zmniejszamy licznik w obiekcie udostępnionym w ramach onPostExecute. Ponieważ onPostExecute działa na tym samym wątku (głównym wątku), nie musisz się martwić o synchronizację.

UPDATE 1

Wspólna obiekt może wyglądać następująco:

public class WorkCounter { 
    private int runningTasks; 
    private final Context ctx; 

    public WorkCounter(int numberOfTasks, Context ctx) { 
     this.runningTasks = numberOfTasks; 
     this.ctx = ctx; 
    } 
    // Only call this in onPostExecute! (or add synchronized to method declaration) 
    public void taskFinished() { 
     if (--runningTasks == 0) { 
      LocalBroadcastManager mgr = LocalBroadcastManager.getInstance(this.ctx); 
      mgr.sendBroadcast(new Intent("all_tasks_have_finished")); 
     } 
    } 
} 

UPDATE 2

Zgodnie z uwagami do tej odpowiedzi, PO szuka rozwiązania w którym może uniknąć budowania nowej klasy. Można to zrobić poprzez dzielenie AtomicInteger wśród potomnych AsyncTask s:

// TODO Update type params according to your needs. 
public class MyAsyncTask extends AsyncTask<Void,Void,Void> { 
    // This instance should be created before creating your async tasks. 
    // Its start count should be equal to the number of async tasks that you will spawn. 
    // It is important that the same AtomicInteger is supplied to all the spawned async tasks such that they share the same work counter. 
    private final AtomicInteger workCounter; 

    public MyAsyncTask(AtomicInteger workCounter) { 
     this.workCounter = workCounter; 
    } 

    // TODO implement doInBackground 

    @Override 
    public void onPostExecute(Void result) { 
     // Job is done, decrement the work counter. 
     int tasksLeft = this.workCounter.decrementAndGet(); 
     // If the count has reached zero, all async tasks have finished. 
     if (tasksLeft == 0) { 
      // Make activity aware by sending a broadcast. 
      LocalBroadcastManager mgr = LocalBroadcastManager.getInstance(this.ctx); 
      mgr.sendBroadcast(new Intent("all_tasks_have_finished"));  
     } 
    } 
} 

Answer 2

Powinieneś użyć CountDownLatch. Oto dokumentacja z przykładami: java.util.concurrent.CountDownLatch

Zasadniczo daje odniesienie CountDownLatch do swoich wątków, a każdy z nich będzie go zmniejszać po zakończeniu:

countDownLatch.countDown(); 

główny wątek będzie czekać na zakończenie wszystkich wątki za pomocą:

countDownLatch.await(); 

Answer 3

Inną opcją może być przechowywanie wszystkich nowych wątków w tablicy.

Następnie można wykonać iterację po tablicy i poczekać z wątkiem [i] .join, aby zakończyć wątek.

zobaczyć dołączyć() http://developer.android.com/reference/java/lang/Thread.html#Thread(java.lang.Runnable)

Po zakończeniu iteracji wszystkie wątki są zrobione i można pracować na