First, the role of join thread

Join() method: Thread provides a thread to wait for another thread to complete. When a join method (t2.join()) of another thread (such as a t2 thread) is called in a program execution flow (such as the main thread), the calling thread (main thread) will be blocked until it is added by the join() method. The join thread (t2.start()) is executed.

Second, the display code analysis

1, when there is no join method

    public class MyJoinTest implements Runnable {
    
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "====" + i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            MyJoinTest myJoinTest = new MyJoinTest();
                         Thread t1 = new Thread(myJoinTest, "normal thread");
                         Thread t2 = new Thread(myJoinTest, "thread of join");
                         T1.start(); //Start t1 thread
    
                         / / Below belongs to the main main thread
            for (int i = 0; i < 10; i++) {
                if (i == 5) {
                                         T2.start(); //Start t2 thread
                }
                System.out.println(Thread.currentThread().getName() + "====" + i);
            }
        }
    }

The output is
main====0
main====1
main====2
main====3
main====4
normal thread ====0
normal thread ====1
normal thread ====2
Ordinary thread ====3
Normal Thread ====4
main====5
main====6
main====7
main====8
main====9
join thread ====0
join thread ====1
join thread ====2
join thread ====3
join thread ====4

2, when there is a join method

    public class MyJoinTest implements Runnable {
    
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "====" + i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            MyJoinTest myJoinTest = new MyJoinTest();
            Thread t1 = new Thread(myJoinTest, "normal thread");
                         Thread t2 = new Thread(myJoinTest, "thread of join");
                         T1.start(); //Start t1 thread
    
                         / / Below belongs to the main main thread
            for (int i = 0; i < 10; i++) {
                if (i == 5) {
                                         T2.start(); //Start t2 thread
                                         //The main thread calls the join method of the t2 thread, causing the main thread to wait for the end of t2 execution before it can execute downward.
                    t2.join();
                }
                System.out.println(Thread.currentThread().getName() + "====" + i);
            }
        }
    }

The output is
main====0
main====1
main====2
main====3
main====4
normal thread ====0
normal thread ====1
normal thread ====2
Ordinary thread ====3
Normal Thread ====4
join thread ====0
join thread ====1
join thread ====2
join thread ====3
join thread ====4
main====5
main====6
main====7
main====8
main====9

3, the source code of the join () method

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;
            }
        }
    }

From the source code, you can see that the principle of the join method is to call the wait method of the corresponding thread to wait for operation. For example, the join method of the B thread is called in the A thread, which is equivalent to calling the wait method of the B thread in the A thread. When the B thread finishes executing (or arrives at the waiting time), the B thread will automatically call its own notifyAll method to wake up the A thread, thus achieving the purpose of synchronization.