Multithread 02 thread join

join Use

effect ： Ensure the visibility of thread execution results

/**
 * @Author: wy
 */
public class MyThread {
    private static Integer i = 1;
    private static Integer j = 2;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            i=j+1;
            j=i;
        });

        Thread thread2 = new Thread(() -> {
            i=3;
            j=i;
        });
        thread1.start(); 
        thread2.start(); 

        Thread.sleep(100);

        System.out.println("i:"+i);
        System.out.println("j:"+j);

    }
}

In the above code , In the ideal state, if thread1 and thread2 If it is executed in sequence , The result that we should get is i=4,j=4.

But we know that , We just did start Method , Does not mean that the thread starts running , Not immediately run Method .

At this point, the thread just becomes ready , Which thread executes depends on the scheduling algorithm of the operating system .（window Medium is preemptive , That is, which thread grabs cpu Resources will not be released until the thread is completed .

linux Medium is time-sharing scheduling , That is, the execution time of a given thread , When the time comes, no matter whether the execution is completed or not, the resources must be released ）

In order to ensure that thread1 Do it after the execution thread2 Words , have access to join Method .

/**
 * @Author: wy
 */
public class MyThread {
    private static Integer i = 1;
    private static Integer j = 2;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            i=j+1;
            j=i;
        });

        Thread thread2 = new Thread(() -> {
            i=3;
            j=i;
        });
        thread1.start();
        thread1.join(); // Use join Method , Pause the current process , know thread1 Completion of execution 
        thread2.start();

        Thread.sleep(100);

        System.out.println("i:"+i);
        System.out.println("j:"+j);

    }
}

  In this way, we can guarantee thread2 really thread1 Executed after execution .

Why?

join End the current process , Until the specified execution is completed .

  From this picture, we can see thread2 really thread1 After that .

Again join We can see in the code of

    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()) {
                // call wait Method 
                wait(0);

            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

  Here it is. join It is through wait, and notify To operate the process to achieve this effect .