I&#39;m confused in `join()` method used in Threads in Java. In the following code:

    // Using join() to wait for threads to finish.
    class NewThread implements Runnable {

        String name; // name of thread
        Thread t;

        NewThread(String threadname) {
            name = threadname;
            t = new Thread(this, name);
            System.out.println(&quot;New thread: &quot; + t);
            t.start(); // Start the thread
        }
    // This is the entry point for thread.

        public void run() {
            try {
                for (int i = 5; i &gt; 0; i--) {
                    System.out.println(name + &quot;: &quot; + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                System.out.println(name + &quot; interrupted.&quot;);
            }
            System.out.println(name + &quot; exiting.&quot;);
        }
    }

    class DemoJoin {

        public static void main(String args[]) {
            NewThread ob1 = new NewThread(&quot;One&quot;);
            NewThread ob2 = new NewThread(&quot;Two&quot;);
            NewThread ob3 = new NewThread(&quot;Three&quot;);
            System.out.println(&quot;Thread One is alive: &quot;
                    + ob1.t.isAlive());
            System.out.println(&quot;Thread Two is alive: &quot;
                    + ob2.t.isAlive());
            System.out.println(&quot;Thread Three is alive: &quot;
                    + ob3.t.isAlive());
    // wait for threads to finish
            try {
                System.out.println(&quot;Waiting for threads to finish.&quot;);
                ob1.t.join();
                ob2.t.join();
                ob3.t.join();
            } catch (InterruptedException e) {
                System.out.println(&quot;Main thread Interrupted&quot;);
            }
            System.out.println(&quot;Thread One is alive: &quot;
                    + ob1.t.isAlive());
            System.out.println(&quot;Thread Two is alive: &quot;
                    + ob2.t.isAlive());
            System.out.println(&quot;Thread Three is alive: &quot;
                    + ob3.t.isAlive());
            System.out.println(&quot;Main thread exiting.&quot;);
        }
    }

Sample output from this program is shown here:

    New thread: Thread[One,5,main]
    New thread: Thread[Two,5,main]
    New thread: Thread[Three,5,main]
    Thread One is alive: true
    Thread Two is alive: true
    Thread Three is alive: true
    Waiting for threads to finish.
    One: 5
    Two: 5
    Three: 5
    One: 4
    Two: 4
    Three: 4
    One: 3
    Two: 3
    Three: 3
    One: 2
    Two: 2
    Three: 2
    One: 1
    Two: 1
    Three: 1
    Two exiting.
    Three exiting.
    One exiting.
    Thread One is alive: false
    Thread Two is alive: false
    Thread Three is alive: false
    Main thread Exiting

In the above code :

1. I&#39;m not able to understand the flow of execution of the program, And when `ob1` is created then the constructor is called where  `t.start()` is written but still `run()` method is not executed rather `main()` method continues execution. So why is this happening?

2. `join()` method is used to wait until the thread on which it is called does not terminates, but here in output we see alternate outputs of the thread why??

And if the use of `join` is this then what is the use of `synchronized`??

I know I&#39;m missing a basic concept here, but I&#39;m not able to figure it out so please help.

All Pthread Join Solutions on Gang of Coders

Total of 1 Pthread Join Solutions

Java Multithreading concept and join() method