重新打开应用程序时，如何检查上一个会话中的线程是否仍在运行？

Question

My application is starting a continously running thread which runs a while(true){}. When I reopen/reenter the application another thread is created and works concurrently with the previous. I would like a mechanism which could check whether a thread from a previous session is still running and if it does then it shouldn't recreate it. How to achieve that?

Answer 1

One way: Create a preference file with a simple boolean to say running or not.
http://developer.android.com/guide/topics/data/data-storage.html#pref

Answer 2

In your thread create a

Boolean isRunning = false;

When your thread starts put it in the apps shared preference like this..

  isRunning = true;
  SharedPreferences settings = getSharedPreferences("isThreadRunning", 0);
  SharedPreferences.Editor editor = settings.edit();
  editor.putBoolean("isRunning", isRunning);
  editor.commit();

Now when the thread is Finished just change it back to false.

isRunning = false;

In your activity just pull the boolean out of shared preference like this.

   SharedPreferences settings = getSharedPreferences("isThreadRunning", 0);
   boolean running = settings.getBoolean("silentMode", false); //if it doesnt exist it will automatically set to false which means the thread hasnt or isnt running

 then just test.

 if(running){
 //Do something
 }else{
 //the thread isnt running so lets start it.
 }

This is a very easy way to do it.

Hope it helps

Answer 3

I wrote a simple thread listing a while back. user1031312 has a better solution, but here it is anyways in case it's useful to you. Not sure if it will list threads from a previous session though. It will list the thread names and id's in a TextView called thread_textview.

// This method recursively visits all thread groups under 'group'.
public static void visit(ThreadGroup group, int level) {
    // Get threads in 'group'
    int numThreads = group.activeCount();
    Thread[] threads = new Thread[numThreads*2];
    numThreads = group.enumerate(threads, false);

    // Enumerate each thread in 'group'
    for (int i=0; i<numThreads; i++) {
        // Get thread
        thread_textview.append("-> "+threads[i].getName()+":"+threads[i].getId()+"\n");
    }

    // Get thread subgroups of 'group'
    int numGroups = group.activeGroupCount();
    ThreadGroup[] groups = new ThreadGroup[numGroups*2];
    numGroups = group.enumerate(groups, false);

    // Recursively visit each subgroup
    for (int i=0; i<numGroups; i++) {
        visit(groups[i], level+1);
    }
}

Answer 4

You can use a ServerSocket to bind to a port. At one time the OS will only allow one thread to be bound. This will prevent the next one to not execute.

ServerSocket serverSocket = new ServerSocket(1234);

For next thread it will throw BindException. So first line in your thread and it will do what you want.

ps 1234 is an unused port number.

Another option -- the above answer is probably not suitable to what you want so here is another option.

public MyThreadFactory {

     List<String> runningThreads = new List<String>();

     public synchronized void startThread(MyThread thread) {
          if (! runningThreads.contains(thread.getID())) {
                runningThreads.add(thread.getID());
                // MyThread implements Runnable
                new Thread(thread).start();
          }
     }
}

assuming your thread object has getID method or something that uniquely identifies its type.