Java多线程join()方法

一、概述

1、join():等待这个线程死亡，相当于join(0)。
2、join(int n) ：最多等待n毫秒之后在处理
-2.1、join的时间 < sleep的时间，那么sleep就会停止，运行时间就是join的时间
-2.2、join的时间 > sleep的时间，那么sleep就会接着运行，运行时间是sleep的时间；
注意：join是Thread类中的方法，要用Thread来进行调用处理。join的底层是wait()
t1.join()表示： 等待t1线程运行结束之后，程序才能接着运行，接着执行。
使用情况：一个线程要等待另外一个线程执行完成，然后得到他的结果的时候使用。

二、演示

1、创建两个线程，t1线程要等待t2线程结束之后，才能进行运行的处理。

public class Test09 {
    public static void main(String[] args) {
        // 创建t1线程
        Thread t1 = new Thread(() -> {
            System.out.println("t1");
        });

        // 创建t2线程
        Thread t2 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2");
        });

        // 等t2结束之后执行t1
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.start();

    }
}

运行结果：

2、使用等待线程的运行结果的处理，我们在t1线程中对变量进行了修改，然后等待这个结果

public class Text05 {
    int i = 0;
    public static void main(String[] args) {
        Text05 text05 = new Text05();
        text05.f();
    }

    public void f(){
        // 创建线程，在线程中给i进行赋值
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    i = 10;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread t1 = new Thread(runnable);
        // 运行线程
        t1.start();
        System.out.println("未使用join的结果为："+i);
        try {
            // join等待thread线程结束之后，在接着运行
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用了join的结果为："+i);

    }
}

运行结果：

3、join(int n) 的处理：
* 等够时间 和 没等够时间的处理

• 1、join的时间 < sleep的时间，那么sleep就会停止，运行时间就是join的时间
• 2、join的时间 > sleep的时间，那么sleep就会接着运行，运行时间是sleep的时间

public class Text06 {
    int i = 0;
    public static void main(String[] args) {
        Text06 text06 = new Text06();
        text06.test();
    }

    public  void test(){
        Thread thread = new Thread() {
            @Override
            public void run() {
                // sleep -> 2s的处理
                try {
                    TimeUnit.SECONDS.sleep(2);
                    i=20;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        long start = System.currentTimeMillis();
        thread.start();

        try {
            // join的时间没有sleep的时间长，会直接终止睡眠
            thread.join(1500);
            // join的时间比sleep长，实际消耗的时间就是sleep的时间，
//             thread.join(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        log.debug("输出的结果为："+i+"，消耗的时间为： "+(end - start));
        System.out.println("输出的结果为："+i+"，消耗的时间为： "+(end - start));
    }
}

thread.join(1500)没等够时间 运行结果：线程没运行完就结束了，没得到i的赋值

thread.join(4000)等够时间 运行结果：线程运行完了，得到了i的赋值