Confused with join concept

[Dhananjay Deshmukh]

I m getting confused to as what exactly is the function of join. Below is the code that i used in two ways:
1st: Used with Join
2nd: Used with sleep:

Below is the code :

class NewThread implements Runnable {
	  String name; // name of thread
	  Thread t;

	  NewThread(String threadname) {
	    name = threadname;
	    t = new Thread(this, name);
	    System.out.println("New thread: " + t);
	    t.start(); // Start the thread
	  }

	  // This is the entry point for thread.
	  public void run() {
	    try {
	      for(int i = 5; i > 0; i--) {
	        System.out.println(name + ": " + i);
	        Thread.sleep(1000);
	      }
	    } catch (InterruptedException e) {
	      System.out.println(name + " interrupted.");
	    }
	    System.out.println(name + " exiting.");
	  }
	}

class DemoJoin {
	  public static void main(String args[]) {
	    NewThread ob1 = new NewThread("One");
	    NewThread ob2 = new NewThread("Two");
	    NewThread ob3 = new NewThread("Three");

	    System.out.println("Thread One is alive: "
	                        + ob1.t.isAlive());
	    System.out.println("Thread Two is alive: "
	                        + ob2.t.isAlive());
	    System.out.println("Thread Three is alive: "
	                        + ob3.t.isAlive());
	    // wait for threads to finish
	    try {
	      /*System.out.println("Waiting for threads to finish.");
	      ob1.t.join();
	      ob2.t.join();
	      ob3.t.join();*/
	    	Thread.sleep(10000);
	    } catch (InterruptedException e) {
	      System.out.println("Main thread Interrupted");
	    }

	    System.out.println("Thread One is alive: "
	                        + ob1.t.isAlive());
	    System.out.println("Thread Two is alive: "
	                        + ob2.t.isAlive());
	    System.out.println("Thread Three is alive: "
	                        + ob3.t.isAlive());

	    System.out.println("Main thread exiting.");
	  }
	}

In both the cases I get the same output as follows :

New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
One: 5
New thread: Thread[Three,5,main]
Two: 5
Thread One is alive: true
Three: 5
Thread Two is alive: true
Thread Three is alive: true
Two: 4
One: 4
Three: 4
Two: 3
Three: 3
One: 3
One: 2
Two: 2
Three: 2
Two: 1
Three: 1
One: 1
One exiting.
Three exiting.
Two exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
Main thread exiting.

Why is it that both the cases are giving the same output? I feel like there is no purpose to use join here

[Campbell Ritchie]

What do you know about fork and join? The idea is you divide your task into several parts which can be done separately (fork) and then put them back together (join). Are you actually using them in the example above?

[Greg Charles]

The join() method called on a thread (ob2.t for example) blocks the thread making the call from going forward (here your main application thread) until the other thread finishes its processing. When you call Thread.sleep(n), you stop your current thread for about n milliseconds, then go on processing. Since your created threads take about six seconds to complete, the only effective difference in this particular example is that the Thread.sleep(10000) is probably slower. In general, you might not know how long a thread will take to finish its work, and so the join() method can be safer ... that is if it is actually important to wait until a thread finishes before doing some other work.

[Dhananjay Deshmukh]

Greg Charles wrote:The join() method called on a thread (ob2.t for example) blocks the thread making the call from going forward (here your main application thread) until the other thread finishes its processing. When you call Thread.sleep(n), you stop your current thread for about n milliseconds, then go on processing. Since your created threads take about six seconds to complete, the only effective difference in this particular example is that the Thread.sleep(10000) is probably slower. In general, you might not know how long a thread will take to finish its work, and so the join() method can be safer ... that is if it is actually important to wait until a thread finishes before doing some other work.

All i could muster from your answer is that thread is basically unpredictable. I guess i will have to study more in order to understand the concept. and clear it. Perhaps i will try more programming. May be involving more interfaces will help, i have a plan.

[Campbell Ritchie]

Yes, threads are unpredictable. Have you read the tutorial link I posted yesterday?

[Dhananjay Deshmukh]

Yes I did. I guess the concept becomes clear when I see it in a big picture or atleas a scenario big enough, but I have to study many topics before I can understand and I have to try programming few scenarios. Untill then I will have doubts. So let me try programming and debugging for couple of days. But that's for the link

[Dhananjay Deshmukh]

Greg Charles wrote:The join() method called on a thread (ob2.t for example) blocks the thread making the call from going forward (here your main application thread) until the other thread finishes its processing. When you call Thread.sleep(n), you stop your current thread for about n milliseconds, then go on processing. Since your created threads take about six seconds to complete, the only effective difference in this particular example is that the Thread.sleep(10000) is probably slower. In general, you might not know how long a thread will take to finish its work, and so the join() method can be safer ... that is if it is actually important to wait until a thread finishes before doing some other work.

I just wanted to check one more thing if i m getting the concept right. Lets just say threads one two and three have started and are in line for the resource. At the moment ob1.t.join() executes , ob1.t is calling sleep in run method and releasing the control making way for ob2.t to execute and then ob3.t. And the process goes on in which case ob1.t comes into life again and the same process goes on. Am i getting it right.

[Greg Charles]

Dhananjay Deshmukh wrote:
I just wanted to check one more thing if i m getting the concept right. Lets just say threads one two and three have started and are in line for the resource. At the moment ob1.t.join() executes , ob1.t is calling sleep in run method and releasing the control making way for ob2.t to execute and then ob3.t. And the process goes on in which case ob1.t comes into life again and the same process goes on. Am i getting it right.

Yes, I think you have it right. When the main thread calls ob1.t.join(), that doesn't actually have any effect at all on the ob1.t thread. Whatever it's doing, it's going to keep doing, whether that's executing or sleeping. All the join does is tell the main thread to wait until the ob1.t thread completes it processing and sleeping entirely, before it (the main thread) continues its own processing.

If an analogy helps, let's say the boss needs some information for a call she will make to the board later in the day. She splits the work of obtaining the information into three pieces and gives one piece to each of her three employees, and she tells them to meet her in the conference room when they finish. As soon as all three return to the conference room with the results of their work, she makes her call to the board. That's like the join() method. It doesn't matter if the three employees slept for most of the time they said they were working. She still waits for all three to be done before going on.

On the other hand, she could have also set her three employees to work, and then herself have gone to sleep on the conference room table for an hour. In that case, when she wakes up, she calls the board immediately without waiting for her employees. That's like the sleep() method. If they had all finished their work by that time, then she has all the information she needs for her phone call. It's not ideal though, because the employees might have all finished their work in five minutes, and she made the board wait 55 extra minutes for no good reason. It's worse though if it took one ore more of those employees more than an hour to finish the work. In that case, the boss calls the board and then doesn't have all the information she promised them.

[Dhananjay Deshmukh]

Greg Charles wrote:

Dhananjay Deshmukh wrote:
I just wanted to check one more thing if i m getting the concept right. Lets just say threads one two and three have started and are in line for the resource. At the moment ob1.t.join() executes , ob1.t is calling sleep in run method and releasing the control making way for ob2.t to execute and then ob3.t. And the process goes on in which case ob1.t comes into life again and the same process goes on. Am i getting it right.

Yes, I think you have it right. When the main thread calls ob1.t.join(), that doesn't actually have any effect at all on the ob1.t thread. Whatever it's doing, it's going to keep doing, whether that's executing or sleeping. All the join does is tell the main thread to wait until the ob1.t thread completes it processing and sleeping entirely, before it (the main thread) continues its own processing.

If an analogy helps, let's say the boss needs some information for a call she will make to the board later in the day. She splits the work of obtaining the information into three pieces and gives one piece to each of her three employees, and she tells them to meet her in the conference room when they finish. As soon as all three return to the conference room with the results of their work, she makes her call to the board. That's like the join() method. It doesn't matter if the three employees slept for most of the time they said they were working. She still waits for all three to be done before going on.

On the other hand, she could have also set her three employees to work, and then herself have gone to sleep on the conference room table for an hour. In that case, when she wakes up, she calls the board immediately without waiting for her employees. That's like the sleep() method. If they had all finished their work by that time, then she has all the information she needs for her phone call. It's not ideal though, because the employees might have all finished their work in five minutes, and she made the board wait 55 extra minutes for no good reason. It's worse though if it took one ore more of those employees more than an hour to finish the work. In that case, the boss calls the board and then doesn't have all the information she promised them.

Thanks i guess i have the general idea of how the join works and it will become more clear with time, i just have to practice more examples.