Thread join on itself

Question

I am in doubt, what happens when a thread joins itself. i.e thread calls the join method on its own. I am not getting any error.

Sample :

public class JoinItself extends Thread {

    public void run() {
        System.out.println("Inside the run method ");
        System.out.println(Thread.currentThread().isAlive());
        for(int i=0;i<5;i++) {
            try {
                System.out.println("Joining itself ...");
                Thread.currentThread().join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {

        JoinItself j = new JoinItself();

        System.out.println(j.isAlive());
        j.start();
        System.out.println(j.isAlive());
        System.out.println("Thread started ...");

    }

}

But Why? Should I get any error?

I most enjoyed both the question and this peace of code: Thread.currentThread().isAlive()! Cannot wait for a process trying to get its own exit code! :D — Vladimir Dyuzhev, May 14 '11 at 04:32

score 36 · Accepted Answer · answered May 14 '11 at 03:18

36

The concept of a thread joining itself does not make sense.

It happens out that the join() method uses the isAlive() method to determine when to return from the join() method. In the current implementation, it also does not check to see if the thread is joining itself.
In other words, the join() method returns when and only when the thread is no longer alive. This will have the effect of waiting forever.

answered May 14 '11 at 03:18

Saurabh Gokhale

53,625
36
139
164

5

Worth noting that you can call `join()` outside of `run()` and it will return when `run()` has finished. Useful inside a shutdown method. – Steve Aug 05 '11 at 12:47

score 3 · Answer 2 · answered May 14 '11 at 07:32

Should I get any error ?

I wouldn't expect an error. The javadocs for Thread.join() do not say that this is an error, and it is just conceivable that some crazy person may use this as another way of doing a sleep, so an undocumented error would be a bad idea.

I guess that Sun didn't think this was a case that was worth giving special attention to.

score 0 · Answer 3 · answered Dec 23 '18 at 08:26

0

The join waits for notification from the other thread. In this case same thread is waiting for itself to notify and hence no notification is received. The program will never end.

answered Dec 23 '18 at 08:26

bina ramani

1
1

score 0 · Answer 4 · answered Sep 03 '20 at 10:09

we can check the join() source code:

public final void join() throws InterruptedException {
    join(0);
}
public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}
public final synchronized void join(long millis, int nanos)
throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }
    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }
    join(millis);
}

it depends on how your join yourself thread and the alive() method
may this post can make it clear Quick start Java Thread join

Thread join on itself

4 Answers4

Linked

Related