I am trying to follow this example in order to understand the join() method:

```
class PrintDemo {

   public void printCount() {

      try {

         for(int i = 5; i > 0; i--) {
            System.out.println("Counter   ---   "  + i );
         }
      } catch (Exception e) {
         System.out.println("Thread  interrupted.");
      }
   }
}

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   PrintDemo  PD;

   ThreadDemo(String name,  PrintDemo pd) {
      threadName = name;
      PD = pd;
   }

   public void run() {

      synchronized(PD) {
         PD.printCount();
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }

   public void start () {
      System.out.println("Starting " +  threadName );

      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      PrintDemo PD = new PrintDemo();

      ThreadDemo T1 = new ThreadDemo("Thread - 1 ", PD);
      ThreadDemo T2 = new ThreadDemo("Thread - 2 ", PD);

      T1.start();
      T2.start();

      // wait for threads to end
      try {
         T1.join();
         T2.join();
      } catch (Exception e) {
         System.out.println("Interrupted");
      }
   }
}

```

I understood that T1.join() for example makes the main thread wait for T1 to finish in order to continue with its flow. Am I correct here?

So, I modified the code like this:

```
      System.out.println("1");
      T1.start();
      System.out.println("2");
      T2.start();

      // wait for threads to end
      try {
         System.out.println("3");
         T1.join();
         System.out.println("4");
         T2.join();
         System.out.println("5");
      } catch (Exception e) {
         System.out.println("Interrupted");
      }

```

in order to try and follow the complete flow.

And this is what I get every time:

```
1
Starting Thread - 1 
2
Starting Thread - 2 
3
4
5
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 1  exiting.
Counter   ---   5
Counter   ---   4
Counter   ---   3
Counter   ---   2
Counter   ---   1
Thread Thread - 2  exiting.

```

and I cannot explain it...

How come the counter prints were printed after the "5" character???
I probably don't understand well the join issue...
['https://Stackoverflow.com/questions/48644114', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/2875641/']
You start a thread (A) which starts another thread (B).

You wait for thread A to finish - which is almost immediate as it barely does anything besides kick off thread B - but thread B is still running independently.
> 
> I am trying ... to understand the join() method
> 
> 
> 

`t.join()` is trivially easy to understand. All it does is wait for thread `t` to die. It doesn't do anything else. Most especially, it does not do anything to thread `t`.

A call to `t.join()` will do nothing, and return immediately if `t` has already finished. Otherwise it will do nothing, and it will not return until `t` *is* finished.