如何在java中等待线程的启动

Question

I have a litte race condition in my current android instrumentation test. What I want is:

1. T1: Start Thread T2
2. T2: Do something
3. T1: Join with T2

With step 1 and 3 being Android live cycle events. But because in the instrumentation test everything happens very fast I get:

1. T1: Start Thread T2
2. T1: Join with T2 (which turn out to be a no-op)
3. T2: Do something

Sure I could add a few sleeps to get the desired behaviour but I wonder if there is better way to do it. iE is there a way to make sure the thread which was just start () -ed did actually start for good and is not still sitting in some scheduling queue awaiting start-up.

(Andy boy, do I miss Ada's rendezvous based multitasking)

And to answer mat's question:

  if (this.thread != null && this.thread.isAlive ())
  {
     this.stop.set (true);

     try
     {
        this.thread.join (1000);
     }
     catch (final InterruptedException Exception)
     {
        android.util.Log.w (Actor.TAG, "Thread did not want to join.", Exception);
     } // try
  } // if

As I said: no-op when because the thread has not started yet.

Answer 1

I typically use a CountDownLatch eg see this answer on testing asynchronous processes.

If you want to synchronise the starting of many threads you can also use a CyclicBarrier .

Answer 2

Martin, looking at your code I get the feeling that you may not be using the Thread class the way it was designed to be used. In particular, testing whether the other thread is alive seems like an anti-pattern. In most practical scenarios you can omit the this.thread.isAlive () condition from your code, and the program will still work.

It seems that you're trying to make two threads (that should do two different things) run the same piece of code, and you use logical conditions (such as this.thread != null ) to decide which of the two threads is currently running.

Typically, you'd write two classes each one extending Thread and implementing a run() method. Each run() method realizes the logic of a single thread. Then you'd launch the 2nd thread from the first, and call join() on that 2nd thread to wait for it to complete.

public class SecondThread extends Thread {
  public void run() {
    ...
  }      
}

public class FirstThread extends Thread {
  public void run() {
    // Only FirstThread is running
    ...

    SecondThread st = new SecondThread();
    st.start();

    // Now both threads are running
    ...

    st.join(); // Wait for SecondThread to complete

    // Only FirstThread is running
    ...

  }                
}