Design pattern for modular AsyncTask in Android

Question

I have been using AsyncTask in Android for some time now. I like it because you can run asynchronously, on a background thread, any task you want (by task I mean a block of code).

At the beginning, every time a task should be run asynchronously and/or on a background thread, I bundled its code into an extension of AsyncTask. I sometimes needed to chain multiple of these tasks (one depending on the result of another) and called the next one in AsyncTask.onPostExecute(T data) (once the execution finished), but now I feel my code is cluttered by so much boilerplate code (the AsyncTask skeleton) and the coupling of successive tasks.

On top of that, my AsyncTasks are sometimes launched from another AsyncTask and Android may complain. For example if I want to display some elements in the pre/post executions, this would be a problem when nesting the calls.

In particular, I am searching a way to modularly choose whether a task should be run synchronously/asynchronously, sequentially/in parallel, or together with another. My choice so far has been to have a simple interface Task expecting an implemented execute(T data) method. Then I can bundle one or multiple of them, to run sequentially or in parallel, as defined in blocks such as this one:

public doMultipleActions() {
  runTask(new MyFirstParallelTask(myFirstData)); // running asynchronously in parallel the first task
  runTask(new MySecondParallelTask(mySecondData)); // running asynchronously in parallel the second task

  runTask(new MyFirstSequentialTask(myThirdData, new MySecondSequentialTask(myFourthData, new DummyCallback()))); // running asynchronously sequentially the third and fourth tasks
}

i.e. runTask(Task t) will run the code of Task.execute(T data) into a AsyncTask.doInBackground(T... data) block of code. Sequential tasks also expect another task to be executed in a AsyncTask.onPostExecute(T data) code block.

I have looked at multiple similar questions: Can I chain async task sequentially (starting one after the previous asynctask completes), AsyncTask chaining in Activity (callback?), How to avoid chaining several AsyncTask calls?, most approaching my issue but I could not find anything useful, even though I do not think I am the only one to deal with this.

Is there a better way, an expected way, or even a design pattern on modular usage of AsyncTask in Android?

Answer 1

Multiple AsyncTask can be run in serial or parallel way by using executeOnExecutor with parameter AsyncTask.SERIAL_EXECUTOR or AsyncTask.THREAD_POOL_EXECUTOR.

If you expect a result with a wait mechanism(e.g wait for a task to finish and return a result) then the better way is to use Future. One such implementation is FutureTask which relies on Callable like this:

ExecutorService pool = Executors.newFixedThreadPool(poolSize);
FutureTask<String> future = new FutureTask(new Callable() {
    public String call() {
        ...
    return res;
});
executor.execute(future);

String res = future.get(); 

The last line will block the operation until Callable inside returns its String result. In fact you can even set a timeout for it to finish.

Remember that AsyncTask doesn't only perform asynchronous operation. It also carries out its process on background thread. So you may still use an AsyncTask (or Thread) to do synchronous operations which otherwise would block the UI.