join() method; guarenteed behaviour

[Ram Manoj]

From K&B book.

When one thread calls the join() method of another thread, the currently
running thread will wait until the thread it joins with has completed.

Here is a sample program, I coded to understand join() method.
Here t.join() is invoked from the main method. The 'main' Thread will wait till thread 't' has completed.
Here do I modify the code, if I want the threads 't','t2','t3' be executed one followed by the other irrespective of 'main' Thread.

package manoj.scjp.threads;
 
public class Test12 extends Thread{    
    public static void main(String[] args) {
        Test12 t = new Test12();
        Test12 t2 = new Test12();
        Test12 t3 = new Test12();
        t.start();
        t2.start();
        t3.start();
        System.out.println("before join");
        try{
            t.join();            
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("end of main");
    }
    public void run(){
        for(int i=0;i<3;i++){
            System.out.print(i+" ");
            try{
                sleep(100);                
            }catch(InterruptedException e){
                e.printStackTrace();
            }            
        }
    }
}

Output:0 0 0 before join
1 1 1 2 2 2 end of main

[Karl Prenton]

I'm not sure if you can!
You can synch the run method such that it won't get interrupted but that doesn't guarantee the order of threads started, you specified t then t2 then t3.
Remember that the output you gave is not guaranteed - try running it several times...
[ June 05, 2008: Message edited by: Frank Zito ]

[Ram Manoj]

Hi Frank,

I think there is confusion here.

What I want is 't2' thread join 't' and 't3' thread join 't2'.

So for this how do i modify my code!

[Karl Prenton]

does this help (modifies main method though) ?

    
public class TestJoin extends Thread{
    
    static final Object thisMonitor = new Object();
    
    public static void main(String[] args) {
        TestJoin t = new TestJoin();
        TestJoin t2 = new TestJoin();
        TestJoin t3 = new TestJoin();
        t.start();
        t2.start();
        t3.start();
        System.out.println("before join");
        try{
            t.join();
            t2.join();
            t3.join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("end of main");
    }
 
    public void run(){
        synchronized (thisMonitor) 
        {
            for(int i=0;i<3;i++){
                System.out.println(super.getName() + " " + i + " ");
                try{
                    sleep(100);                
                }catch(InterruptedException e){
                    e.printStackTrace();
                }            
            }
            
        }
    }
}

[Ram Reddy]

hi manoj,

I hope i understood your requirement.
Please find two programs below.

Program 1 :- is like your requirement

program 2:- to execute threads one by one . I think this is not a good approach.

program 1:-


class Test12 extends Thread
{
Thread threadObj = null;
public Test12() {}
public Test12(Thread thread)
{
this.threadObj = thread;
}
public static void main(String...strings)
{
Test12 t = new Test12();
Test12 t2 = new Test12(t);
Test12 t3 = new Test12(t2);
t.start();
t2.start();
t3.start();
System.out.println("before join");
try
{
t.join();
}
catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println("end of main");
}
public void run()
{
System.out.println("Run Method of " + Thread.currentThread().getName());
try
{
if(threadObj != null)
{
threadObj.join();
}
for(int i=0;i<3;i++)
{
System.out.print(i+" ");
sleep(100);
}
System.out.println("End of Thread " + Thread.currentThread().getName());
}
catch(InterruptedException e)
{
System.out.println("Interrupted Exception");
}
}
}

program 2:-



class MainJoin
{
public static void main(String...strings) throws Exception
{
Join j1 = new Join();
Join j2 = new Join();
Join j3 = new Join();
j1.setName("Join Thread 1");
j2.setName("Join Thread 2");
j3.setName("Join Thread 3");
System.out.println("Before starting the thread J1");
j1.start();
System.out.println("Before joining the J1 Thread");
j1.join();
System.out.println("Before starting the thread J2");
j2.start();
System.out.println("Before joining the J2 Thread");
j2.join();
System.out.println("Before starting the thread J2");
j3.start();
System.out.println("Before joining the J3 Thread");
j3.join();
System.out.println("End of the main thread");
}
}

class Join extends Thread
{
public void run()
{
System.out.println("Start of the thread " + Thread.currentThread().getName());
for(int i = 0; i < 10; i++)
{
System.out.println(" I value is " + i);
}
System.out.println("End of the Thread : " + Thread.currentThread().getName());
}
}

Can any one tell me is the second program is a good approach?
If not how to write it another way?

Rami.

[Mustafa Musaji]

I really don't understand how join() works. If join() comes after you have started the threads (which are now for arguments sake are running), when the main hits the join() call for that thread... its a little bit too late as they threads have already started.

As an example, here some code I wrote, wanting the output to be along the lines of a thread starts, that thread finishes before another one starts and finishes and then the last one starts and finishes. This is what I understand the join() method to do.

   
 
package questionOfThreads;
 
public class UsingJoin {
  
  public static void main(String[] args) {
    
    GoingRunning gr1 = new GoingRunning("one");
    GoingRunning gr2 = new GoingRunning("two");
    GoingRunning gr3 = new GoingRunning("three");
    
    gr1.start();
    gr2.start();
    gr3.start();
    
    try {
      gr1.join();
      gr2.join();
      gr3.join();
    }catch (InterruptedException e) {
      
    }
  }
}
 
class GoingRunning extends Thread {
  
  private static int num=10000;
  private String name;
  
  GoingRunning(String name) {
    this.name = name;
  }
  
  public void run() {
    System.out.println(this.name + " started");
    for(int i=0; i<100; i++) {
      if(num < 0) {
        break;
      }
      else {
        num -= 100;
      }
    }
    System.out.println(this.name +  " finished");
  }
}
 
 

What I find is that join() is being called AFTER the threads have all completed!

Actual Output:
one started
three started
two started
one finished
three finished
two finished

Desired Output:
one started
one finished
two started
two finished
three started
three finished


I am 100% sure I am missing some fundamental rule and would appreciate your help.
[ June 06, 2008: Message edited by: Mustafa Musaji ]

[robert stannard]

Hi Mustafa,

to get the output your requiring, I think you need to add the "synchronize" keyword to your "run" method. This I think forces only one thread to access the method at a time. I tried it with your example and it worked for me, although I had to increase your variables quite alot to slow my machine down!!

I hope this helps.

Robert.

[Mustafa Musaji]

Hi Robert,

I agree with you, using synchronize does work, but then there would be no need for the join() method as each thread would access the run method seperately anyway right?

I guess what I am trying to say is I don't quite understand how the join() method is used correctly. When I see it in a mock I just seem to get confused as to what the code will do.

Should I just hope I don't get too many Thread questions in my SCJP Exam!!!

[robert stannard]

Hi Mustafa,

I may have given you a "bum steer" in my previous post. I think you need to add a "synchronized" block to the code and lock on an external Object like "System.out" to lock that bit of code from other Threads. I made this small change to your code,

    
synchronized (System.out) {
System.out.println(this.name + " started");
for (int i = 0; i < 10000000; i++) {
if (num < 0) {
break;
} else {
num -= 10;
}
}
System.out.println(this.name + " finished");
};

which then gives me the Ouput,
One Started
One Finished
Three Started
Three Finished
Two Started
Two Finished

I dont think its possible to tell the scheduler which thread to run next - thats why you have thread "Three" running before thread "Two" - but as you can see from the output, once a thread is in your "Run" method, no other thread can access the code until its finished.

I hope this helps.

[robert stannard]

I think the problem with your Join is that you are joining to the Main thread and not joining one thread to another, so what happens is that the Main thread runs and completes and then the other threads run on after the other in not particular order.

I also struggle with Thread questions and am hoping that I dont have too many difficult ones !

[Mustafa Musaji]

Forgot to say that to use synchronize you would have also have create one "GoingRunning" object and three Thread objects using the same "GoingRunning". Synchronize would only work on the same object.

Basically it would mean I could not create three different objects of GoingRunning and have them access the run() method one after the other using synchronize. I could use synchronized(GoingRunning.class)....

.... anyway, my point is I don't understand join()!!!

[Mustafa Musaji]

Originally posted by robert stannard:
I think the problem with your Join is that you are joining to the Main thread and not joining one thread to another, so what happens is that the Main thread runs and completes and then the other threads run on after the other in not particular order.

I also struggle with Thread questions and am hoping that I dont have too many difficult ones !

This sort of makes sense, but then where would I put the code to join the threads?

[robert stannard]

I don't think you can do that - not from within the Main() method anyway.

I think what I said before about the Join was actually the wrong way around. The way you've coded the Join, "gr1.join()" you're saying join (or run) the Main() thread to the end of this thread gr1 (or gr2 or gr3).
You can observe this effect but making the following small change to your code. Try un-commenting and re-commenting the block and see where the System.out prints. You will see that when the block is commented out the print statement appears at the top of the output and when you uncomment the block it prints at the bottom of the output, showing that the Join statement has kicked in and is stopping the Main() thread from continuing until the other threads have completed.

I dont think you can daisy-chain Joins together like you're trying to do - not in the Main() method anyway.

/*try {
gr1.join();
gr2.join();
gr3.join();
} catch (InterruptedException e) {
 
}*/
System.out.println("main has finished " + Thread.currentThread().getName());
    

[ June 06, 2008: Message edited by: robert stannard ]
[ June 06, 2008: Message edited by: robert stannard ]

[Mustafa Musaji]

Ah yeah I get it. That does make sense. I was making the mistake of thinking that calling gr1.join() was asking that thread to join on the main, but its asking the current thread you're running, in this case "main" to join on gr1 when it has finished.

Is that right?

[robert stannard]

Yes thats exactly right. Its a bit confusing I know.

I dont know how you would daisy-chain gr1 to gr2 to gr3 to build up dependancies there, I dont think it can be done. I think thats what "synchronized" is good for.

I hope that helps.

[Ram Manoj]

Thanks Robert, Mustafa and Reddy in taking this discussion further.

Hi Frank,

Originally posted by Frank Zito:
does this help (modifies main method though) ?

It works wonderfully. And the use of synchronized for ordering is brilliant.
But here the join() method does little.Even if we comment out join() methods, the threads are synchronized and seemingly join each other, but then I suppose the order is not guarenteed.

I have modified my code so it can accomodate multiple threads in an ordered way.

class TestJoin extends Thread{
    
    static final Object thisMonitor = new Object();
    
    public static void main(String[] args) {
        int no = 4;
        TestJoin threads[] = new TestJoin[no];
        
        for(TestJoin th: threads){
            th = new TestJoin();
            th.start();
        }
        System.out.println("before join");
        /*try{
            /*for(TestJoin th: threads){
                th.join();
            }*/
            th[no-1].join();
        }catch(InterruptedException e){
            e.printStackTrace();
        }*/
        System.out.println("end of main");
    }
 
    public void run(){
        synchronized (thisMonitor) 
        {
            for(int i=0;i<3;i++){
                System.out.println(super.getName() + " " + i + " ");
                try{
                    sleep(100);                
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            
        }
    }
}

But then how do we accomplish the same task using join() method instead of using synchronized block code?

Ranchers please put in your views.

[Karl Prenton]

Ram Reddy is correct in suggesting that the join should be in the run method in order to control the order (doh!). The synch only prevents the block from being interrupted (by a similar thread).
Joining the main thread is not the issue, if I understand the problem correctly.

[venkatesh badrinathan]

can anyone please give me a simple example to daisy chain threads?? although i have read threads in detail, i still have some issues writing join() and sychronized methods in program... is there any source where i could get details about join() and synchronized()...???

[Saurabh Vyas]

Hi Guys,

Try this example written by me.

I guess it solves your problem of Running 3 Thread T1, T2, T3 along with main Thread with a condition that T1 should finish first, T2 should finish Second and T3 should finish 3rd and main should finish last. It makes use of join() to accomplish the task.

    
 
public class TestJoin {
 
public static void main(String... args){
 
MyThread t_one = new MyThread();
MyThread t_two = new MyThread();
MyThread t_three = new MyThread();
 
t_one.setName("ONE");
t_two.setName("TWO");
t_three.setName("THREE");
 
t_two.setDependentThread(t_one);
t_three.setDependentThread(t_two);
 
System.out.println("Before JOIN...");
 
t_one.start();
t_two.start();
t_three.start();
 
try{
//t_one.join();
//t_two.join();
t_three.join();
 
}catch(InterruptedException iex){
System.out.println(Thread.currentThread().getName() + " is Interrupted.");
}
 
System.out.println("End of MAIN...");
}
 
}
 
class MyThread extends Thread{
 
private MyThread otherThread;
 
public void setDependentThread(MyThread anotherThread){
this.otherThread = anotherThread;
}
public void run(){
 
if(otherThread != null){
try{
this.otherThread.join();
}catch(InterruptedException iex){
System.out.println(Thread.currentThread().getName() + " is Interrupted.");
}
}
 
for(int i=0; i < 10 ; i++){
System.out.println(Thread.currentThread().getName() + " - " +  i );
}
 
System.out.println("End of " + Thread.currentThread().getName());
}
}
 

Cheers !!
Saurabh

[Sumit Bisht]

Guide me why the foll code does compile(it even runs correctly at runtime and ends up throwing a out of memory exception)

public class ThreadQ implements Runnable{
public void run(){
System.out.println("Current thread "+Thread.currentThread());
Thread t=new Thread(new ThreadQ());//can we do this?
t.setPriority(1);
t.start();//or this??
try{
t.join();//or even this???
}catch(Exception ex){System.out.println(" "+ex);}
}
public static void main(String[] args){
try{
Thread t1=new Thread(new ThreadQ());
t1.start();
}catch(Exception ex){
System.out.println(" "+ex);
}
}
}