Question

我通过将其分成可用核心的确切数量来并行化我的操作，然后通过启动相同数量的AsyncTask，执行相同的操作，但是在不同的数据部分上。

我正在使用executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, ...)来并行执行它们。

我想知道每个线程何时完成其工作，以便结合所有结果并执行进一步的操作。

我该怎么办？

Answer 1

您还可以简单地将共享对象中的计数器减少为onPostExecute的一部分。由于onPostExecute在同一个线程（主线程）上运行，因此您不必担心同步。

更新1

共享对象可能如下所示：

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

更新2

根据对此答案的评论，OP正在寻找一种可以避免建立新课程的解决方案。这可以通过在衍生的AtomicInteger中共享AsyncTask来完成：

// 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

您应该使用CountDownLatch。这里的文档包含示例： java.util.concurrent.CountDownLatch

基本上你给你的线程一个CountDownLatch的引用，并且它们中的每一个都会在完成时减少它：

countDownLatch.countDown();

主线程将使用以下命令终止所有线程：

countDownLatch.await();

Answer 3

另一个选项可能是将所有新线程存储在一个数组中。

然后你可以迭代数组并等待线程[i] .join来完成线程。

查看join（） http://developer.android.com/reference/java/lang/Thread.html#Thread(java.lang.Runnable)

迭代完成后，所有线程都已完成，您可以继续

Answer 4

RX Merge运算符是您的朋友。

摆脱AsyncTark比RX慢，并且您无法处理错误

等待多个AsyncTask完成

4 个答案: