Android多個異步調用

Question

有什麼好的庫來處理android活動中的多個異步調用？我正在尋找一個庫，其中所有的調用都被執行，並且當所有調用都已經完成時返回結果。

Answer 1

這裏有很多方法可以做到這一點，（正如其他建議）RxJava也許是最簡單的人，但男孩的一個......學習RxJava只是這樣一個簡單的任務聽起來這種矯枉過正。

這裏的（延伸AsyncTask）一個簡單的類，這將幫助你做到這一點很容易：

public static abstract class Task<Param, Progress, Result> extends AsyncTask<Param, Progress, Result> { 

    public abstract static class Watcher { 

     private List<Long> watchedIds = new ArrayList<>(); 
     private boolean finished = false; 

     public abstract void onAllTasksFinished(); 

     private void checkIfFinished() { 
      if (finished) { 
       throw new IllegalStateException("This Watcher is already finished. Create a new one."); 
      } 
     } 

     private void watch(Task task) { 
      checkIfFinished(); 
      task.setWatcher(this); 
      watchedIds.add(task.getId()); 
     } 

     private void onFinished(Task task) { 
      checkIfFinished(); 
      watchedIds.remove(Long.valueOf(task.getId())); 
      if (watchedIds.size() == 0) { 
       onAllTasksFinished(); 
      } 
     } 
    } 

    private static long idGenerator = 0; 

    private final long id = idGenerator++; 
    private Watcher watcher; 

    private void setWatcher(Watcher watcher) { 
     this.watcher = watcher; 
    } 

    private long getId() { 
     return id; 
    } 

    @Override 
    protected final void onPostExecute(Result o) { 
     onTaskFinished(o); 
     if (watcher != null) { 
      watcher.onFinished(this); 
     } 
    } 

    protected abstract void onTaskFinished(Result o); 
} 

用法：

// Create a Watcher object 
Task.Watcher watcher = new Task.Watcher() { 
    @Override 
    public void onAllTasksFinished() { 

    } 
}; 

// Create your tasks (you can extend Task class if that fits your needs better) 
Task<String, Object, Date> task1 = new Task<String, Object, Date>() { 
    @Override 
    protected void onTaskFinished(Date o) { 

    } 

    @Override 
    protected Date doInBackground(String... params) { 
     return null; 
    } 
}; 
Task<Long, Integer, String> task2 = new Task<Long, Integer, String>() { 
    @Override 
    protected void onTaskFinished(String o) { 

    } 

    @Override 
    protected String doInBackground(Long... params) { 
     return null; 
    } 
}; 

// Watch tasks in your Watcher object 
watcher.watch(task1); 
watcher.watch(task2); 

// execute tasks (in any way you like ;)) 

Answer 2

試試這個

https://github.com/SilenceDut/AsyncTaskScheduler

這圖書館的選項輕鬆管理多個任務，同時還管理UI線程回調。

Answer 3

你應該明確地看看RxJava。 它允許你從一個點發射東西，在你的數據流之間進行許多轉換（如果你需要的話）並在觀察者站點上得到通知。它還可以輕鬆切換線程（與RxAndroid一起使用）。

Answer 4

我最近用一個ExecutionerCompletionService實現了這個。 take（）方法是等待的部分。參考文件在這裏，代碼示例如下。

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorCompletionService.html

final ExecutorService pool = Executors.newFixedThreadPool(2); 
    final ExecutorCompletionService<Object> completionService 
      = new ExecutorCompletionService<>(pool); 

    completionService.submit(new Callable<Object>() { 
     @Override 
     public Object call() throws Exception { 
      return doApiCallOne(); 
     } 
    }); 

    completionService.submit(new Callable<Object>() { 
     @Override 
     public Object call() throws Exception { 
      return doApiCallTwo(); 
     } 
    }); 

    try { 
     final Future<Object> future1 = completionService.take(); 
     final Future<Object> future2 = completionService.take(); 
     final Object wrapper1 = future1.get(); 
     final Object wrapper2 = future2.get(); 

     final Type1 model1; 
     final Type2 model2; 
     if (wrapper1 instanceof Type1) { 
      model1 = (Type1) wrapper1; 
      model2 = (Type2) wrapper2; 
     } else { 
      model1 = (Type1) wrapper2; 
      model2 = (Type2) wrapper1; 
     } 

    } catch (ExecutionException | InterruptedException e) { 
     event.setResult(false); 
     event.setException(e); 
     e.printStackTrace(); 
    }