exam tomorrow, please help.

[Yuan Ye]

I am not quite sure about how join() works. For example, if in threadA there is a statement as B.join(). If thread B haven't been to a runnable state when threadA encounter the join() method. Would threadA wait until B has run or Would threadA just ignore the join() since B is not running? Thanks. I am waiting for some opinion.

[Marlene Miller]

class B extends Thread {
    public void run() {
        try {
            sleep(3000);
        } catch (InterruptedException e) {}
    }
}
//
class A {
    public static void main(String[] args) {
        B b = new B();
        //
        // thread B is not started, thread B is not alive
        // the join returns immediately
        log();
        try {
            b.join();
        } catch (InterruptedException e) {
        }
        log();
        //
        // thread B is started, thread B is alive
        // the join returns when B.run has completed
        log();
        b.start();
        try {
            b.join();
        } catch (InterruptedException e) {
        }
        log();
    }
    static void log() {
        System.out.println(Thread.currentThread().getName() + " " + System.currentTimeMillis());
    }
}
main 1055567285266
main 1055567285266
main 1055567285266
main 1055567288270

[ June 13, 2003: Message edited by: Marlene Miller ]

[Marlene Miller]

The source code for join() is basically this
while (isAlive()) { wait(0); }
If the thread is not started, then the thread is not alive and join() returns without the current thread (calling thread) waiting. When does the thread become alive? Some time after the thread is started and *presumably* before the run() method is called.
t.start()
t.isAlive() == true
run(){}
Is the thread alive before the start method returns? Or could there be a small window of time after start() returns and before the run() method is called when the thread is not yet alive? None of the Java thread books I have mention such a case.
[ June 14, 2003: Message edited by: Marlene Miller ]

[Yuan Ye]

Thank you very much.

[Marlene Miller]

I have one more comment on the question,
When does the thread become alive? Is there a window of vulnerability when we could issue a join() after calling start() and before the thread isAlive()?

public synchronized native void start();
public final native boolean isAlive();

Native code.

share\native\java\lang\Thread.c
static JNINativeMethod methods[] = {
    {"start",            "()V",        (void *)&JVM_StartThread},
    {"stop0",            "(" OBJ ")V", (void *)&JVM_StopThread},
    {"isAlive",          "()Z",        (void *)&JVM_IsThreadAlive},

The implementation is in the JVM. So you and I cannot know for sure.
However, if you start() a thread, then immediately invoke join() and it returns because the thread never even became alive, that would not be a reliable join(). It�s beyond our control. I vote that this cannot happen.
[ June 14, 2003: Message edited by: Marlene Miller ]

[Anupam Sinha]

Hi Marlene

When does the thread become alive? Is there a window of vulnerability when we could issue a join() after calling start() and before the thread isAlive()?

I guess that this will not happen as the method start() is synchronized.

public synchronized native void start();

[Marlene Miller]

Thank you Anupam. What I should have said is...
Is there a window of vulnerability when we could issue a join() after *returning* from start() and before the thread isAlive()?
In other words, does the thread become alive inside of start()? Or does the thread become alive some time later, just before run() is invoked?

[Anupam Sinha]

Hi Marlene
This is what I think.

In other words, does the thread become alive inside of start()? Or does the thread become alive some time later, just before run() is invoked?

I guess that a thread becomes alive inside the start method because the Thread's class run() method does nothing. Though I am not sure but I guess that the run() method directly follows the start() method.