How to manage multiple Async Tasks efficiently in Android

Question

I have scenario where I will have to make six http calls to my server to get the data for six different items. These server calls cant be combined and they are meant to be t

Answer 1

just stabbing in the dark here, but you have:

• 1x main UI thread
• 6x background asynchtasks which have: 6x methods to execute in background 6x methods to return data to UI (foreground)

why not have a variable of public scope in the UI thread say called "finishedTasks", then the same method in each of the 6x return data threads that:

• increments finishedTasks

• if finishedTasks == 6 then run 1 public method to do the update of the UI

then it would update the UI on all background asychtasks completing.

Answer 2

You could make a AsyncTask pool object that allows you to spoof a 'batch' http call.

1. create an Observable collection of AsyncTasks, i'll refer to this collection as your Pool
2. your Activity creates the AsyncTasks (but not execute yet) and adds them to the Pool
3. Activity registers itself as an observer of the Pool
4. Activity tells Pool to execute, Pool in turn calls execute on each of its Tasks
5. When tasks complete (for both success and fail), they store the response data in the Pool, and the Pool marks the Task as being 'complete'
6. Once all Tasks are marked as complete, Pool notifies the listening Activity

General idea is for the Pool to know how many Tasks and pending, and to store the aggregate data of completed calls. Once all are finished, notify the observing Activity and pass back all the data.

You'll have to work out how the AsyncTasks tell the Pool that they are finished. Maybe simply have an implementation of AsyncTask that takes a Pool on its constructor so that the Tasks have a reference to the Pool.

Answer 3

There are many ways you could handle this:

• Another AsyncTask that aggregates the responses from the network tasks.
• Perform a sendEmptyMessageDelayed() every, say, 500ms to a Handler created by your Activity that refreshes the data that has come in from the network tasks and continues to do so until all of the networking results are dealt with.
• A Thread that performs the aggregation.

Were it me, I'd probably go with the Handler. To sum up, have your network tasks store the data in some intermediate storage. Send delayed messages to a handler and, within the handleMessage() check for data in the intermediate storage and post updated results. If there are results outstanding, post the delayed message again.

Answer 4

I found this solution more appropriate to my problem. This link describes a couple of ways of establishing this. 1. ExecutorService 2. ExecutoreService and CountDownLatch

ExecutoreService and CountDownLatch