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