0

What i am trying to achieve is share data between running asynctask (doInBackground). So whats happening is that i have separate class (extends Asynctask) that loads data and activity with its own Async class which i use to update info in the activity. Basicly what i am trying to achieve is the thread in the activity (monitoring thread) to work alongside with the loader and providing some data from the loader class and when the loader is ready both the "monitoring" and the "loader" should die.

I tried having a volatile variable which I set using interfaces, but no success i cant seem to be able to share information between the threads(asynctasks).. Any suggestions? Maybe an Exchanger class is needed?

Alex
  • 389
  • 1
  • 2
  • 14

3 Answers3

1

Any reason you can't use the onProgressUpdate functionality? I may be confused by your use case... but an example might be the following:

class MyActivity extends Activity {

  private AsyncTask<Uri,MyDataObject, MyResult> = new AsyncTask<Uri,MyDataObject, MyResult>() {
    private MyResult mResult;

    protected MyResult doInBackground(Uri... uris) {           
      int count = urls.length;
      mResult = new MyResult()

      for (int i = 0; i < count; i++) {
        MyDataObject anObject = mDataLoader.getObject(uris[i]);
        publishProgress(anObject);

        mResult.add(anObject);
        // Escape early if cancel() is called
        if (isCancelled()) break;
      }
      return totalSize;
    }

    protected void onProgressUpdate(MyDataObject... data) {
      addDataToUI(data[0]);
    }

    protected void onPostExecute(MyResult result) {
      Toast.makeText("All Done!", Toast.LENGTH_LONG).show();
    }
  }
}
JRaymond
  • 11,625
  • 5
  • 37
  • 40
  • OK lets put it that way-> LoadDataClass (asynctask)- progress variable getting set during doInbackground Monitor async task in the activity - > check the progress variable from loaddataclass and display it for example – Alex Feb 23 '13 at 00:10
  • @Alex onProgressUpdate runs on the UI thread, so you pass data into this (that's what the second param in AsyncTask is for) and the OS takes care of the marshalling between threads. Or you can call Activity.runOnUiThread – Rich Feb 23 '13 at 00:24
  • @Alex Updated with an example – JRaymond Feb 23 '13 at 00:27
  • Thanks guys! I`ll try to do something similar,but what about 2 asynctasks exchanging info in general. Even 2 threads? Semaphors and mutexes OK, but 2 or more threads can`t use the same resources when you implement em. Ofcourse who would want 2-3 or more threads to be working in the same space, but for example if 2 people are adding information to an array you might say ok.. how about 2 threads that know which index is used and being used at the moment so they cant interfere with each other? – Alex Feb 23 '13 at 00:40
  • 1
    It's best to use existing utilities wherever possible, such as BlockingQueue as I mentioned in my answer. A BlockingQueue can handle multiple producers, similar to your array example. If you must do something custom, then keeping it as simple as possible is best - e.g. just use coarse-grained locking to ensure serial access rather than trying to implement a non-locking solution with volatiles. I'd recommend reading [Java Concurrency In Practice](http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601) as the go-to book. – Jason Sankey Feb 23 '13 at 01:39
  • @Alex In android you can also use the message passing methods added by Google to the thread construct. Take a look at using Handlers (http://developer.android.com/reference/android/os/Handler.html). The construct basically turns a Java Thread into a loop that executes messages passed to it. It's how AsyncTask is put together under the covers – JRaymond Feb 23 '13 at 02:13
1

It sounds like you want to have the Activity show some information as the data is loaded by the loader thread? So you need to pass some information from the loader into the Activity, updating the UI. In this case I'm not sure you need a second AsyncTask (and associated thread) in the Activity, as you still need to get the data to the main thread before you can update the UI. Instead, you should do as JRaymond suggests and just push the changes to the main thread using publishProgress and handle them on the main thread in onProgressUpdate

If you need something more general, you could also consider using java.util.concurrent. For example, a BlockingQueue can be used to implement the consumer/producer pattern. See the Javadoc for a code snippet.

Community
  • 1
  • 1
Jason Sankey
  • 2,328
  • 1
  • 15
  • 12
  • FYI, the onProgressUpdate method of an Async task happens on the UI thread; AsyncTask was written to help people avoid the details of handlers (Although I usually find them to be more trouble than they're worth) – JRaymond Feb 23 '13 at 00:16
  • You're quite right, using a Handler as I suggest is just a manual way of reimplementing onProgressUpdate. I'll amend my answer. – Jason Sankey Feb 23 '13 at 00:18
0

All async tasks (unless executed with the executor provided) run on the same background thread, so it is not possible to execute them concurrently.

From documentation:

When first introduced, AsyncTasks were executed serially on a single background thread. Starting with DONUT, this was changed to a pool of threads allowing multiple tasks to operate in parallel. Starting with HONEYCOMB, tasks are executed on a single thread to avoid common application errors caused by parallel execution.

If you truly want parallel execution, you can invoke executeOnExecutor(java.util.concurrent.Executor, Object[]) with THREAD_POOL_EXECUTOR.

Stijak
  • 91
  • 4