Effect of peripheral Java threads' methods' background work on the calling thread

Question

I have a Java-based app (Android) and I'd like to be able to perform potentially long operations in the background. The Android docs on AsyncTask advise against using them for tasks that may run for more than a few seconds (why is this?) so I'm using a subclass of Java's Thread instead. The goal of this Thread subclass (HPCHeadThread) is mainly to host the instances of a few asynchronous control mechanisms, and provide accessor methods to said mechanisms for other threads to use. The workflow I'm aiming for is to be able to call hHPCHeadThread.doStuff() from any thread with a reference to HPCHeadThread, and have the control objects instantiated in HPCHeadThread do work on the HPCHeadThread thread and only on that thread. When not being accessed by another thread, HPCHeadThread should sleep so as not to waste CPU cycles. I launch the peripheral thread HPCHeadThread from the main thread (TestActivity) like so:

TestActivity.java

//..snip
private HPCHeadThread hHPCHeadThread;

@Override
protected void onCreate(Bundle savedInstanceState){
  super.onCreate(savedInstanceState);
  //...snip 

  //Create and start our HPCHeadThread
  hHPCHeadThread = HPCHeadThread.getHPCThreadHead();
  hHPCHeadThread.start();

  //..snip
}

HPCHeadThread.java

//..snip
public class HPCHeadThread extends Thread {
  private static volatile HPCHeadThread instance;
  private static boolean bIsActive = true;


  private HPCHeadThread(){
    super();        
  }

  public static HPCHeadThread getHPCThreadHead(){

    if(instance == null && bIsActive){
      instance = new HPCHeadThread();   
    }

    return instance;

  }


  public void safeStop(){
    instance = null;
    bIsActive = false;
  }

  @Override
  public void run(){
  Thread thisThread = Thread.currentThread();
  Thread.currentThread().setName("HPC_Head_Thread");

  while(instance == thisThread){
    //Our HPCHeadThread 'main' loop
    //Try to have it sleep whenever it isn't being used
    //Hopefully it will wake nicely upon attempted access,
    //perform the desired function, and then return to sleep


      try{
        Thread.sleep(10000);
      }
      catch (InterruptedException e){
        //e.printStackTrace();
      }

    }//End while
  }//End Run()

  public void doStuff(){
    //..snip stuff..
  }

}

Now if I invoke hHPCHeadThread.doStuff() from within my main TestActivity thread, does the work process on HPCHeadThread or on the main TestActivity thread? Does TestActivity wait for the doStuff() method to return before continuing sequential execution within its own thread? Do method invocations wake HPCHeadThread and/or do they cause an InterruptedException to be thrown in HPCHeadThread's run() method while loop?

Answer 1

The Android documentation advices against long running threads in activities because activities can be swapped out any time the system needs memory and the app is running in the background.

If you want to do long running tasks: create a Service which is intended for just that: long running tasks that should not be thrown out of when more memory is needed.

On the queue thing: sounds like a good advice. Just use a ArrayBlockingQueue which has a blocking call: take()

Create your workerthread and queue like this:

public class Workqueue implements Runnable {


private static Workqueue theInstance=null;

public static synchronized Workqueue getInstance(){
   if(theInstance==null){
       theInstance=new WorkQueue();
     }
  return theInstance;
  }


private ArrayBlockingQueue<Runnable> queue=new ArrayBlockingQueue<Runnable>();
private Thread workerThread;

private WorkQueue(){
    workerThread=new Thread(this);
    workerThread.start();
}


public void run(){
   while(keepRunning){
      //pick up next task or wait (not using any cpu cycles)
      Runnable r=queue.take();
      //execute task
      r.run();
    }
}

public void addTask(Runnable task){
   queue.add(task);
}

Usage would be:

Runnable newTask= new Runnable(){
public void run(){
   dostuff...
}};
Workqueue.getInstance().addTask(newTask);

This can be called from any thread without blocking it, it adds tasks to the queue which will be executed one by one.

Answer 2

First, I think you can use the old Singleton design pattern to accomplish having one thread accessible from everywhere. It would look something like:

public class MyThread extends Thread () {
  private static MyThread _me;

  private MyThread() { /* make constructors private it can only be made by getting an instance */ }

  public static MyThread getInstance() {
    if(_me == null) {
      _me = new MyThread();
    }
    return _me;
  }
}

Second, calling doStuff() will run in the calling thread. In a Java Thread, all the Thread's processing happenins in the run() method.

Last, you may want to look at implementing wait and notify, or timed waits if the Thread doesn't need to execute immediately.