Thread 的join方法源码解读

最新推荐文章于 2022-05-27 10:38:17 发布

原创最新推荐文章于 2022-05-27 10:38:17 发布 · 326 阅读

0 ·

CC 4.0 BY-SA版权

多线程专栏收录该内容

16 篇文章

订阅专栏

本文详细阐述了Java Thread类中的join方法如何实现线程同步，解释了其在并发编程中的作用，以及join与start调用顺序的重要性。通过实例和源码解析，展示了join方法在串行执行和时间等待上的应用。

一、作用

　　Thread类中的join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。具体看代码：

public class JoinTest {
    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("小明");
        ThreadJoinTest t2 = new ThreadJoinTest("小东");
        t1.start();
        /**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：
         程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕
         所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会
         */
        t1.join();
        t2.start();
    }

}
class ThreadJoinTest extends Thread{
    public ThreadJoinTest(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println(this.getName() + ":" + i);
        }
    }
}

输出结果：

上面注释也大概说明了join方法的作用：在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行，相当于将并行变成了串行。注意，这里调用的join方法是没有传参的，join方法其实也可以传递一个参数给它的。

join方法中如果传入参数，则表示这样的意思：如果A线程中掉用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行，但是具体怎么执行，还得看cpu的调度。需要注意的是，jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。

二、join与start调用顺序问题

　　上面的讨论大概知道了join的作用了，那么，入股 join在start前调用，会出现什么后果呢？先看下面的测试结果：

public class JoinTest {
    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("小明");
        ThreadJoinTest t2 = new ThreadJoinTest("小东");
        /**join方法可以在start方法前调用时，并不能起到同步的作用
         */
        t1.join();
        t1.start();
        //Thread.yield();
        t2.start();
    }

}
class ThreadJoinTest extends Thread{
    public ThreadJoinTest(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=0;i<1000;i++){
            System.out.println(this.getName() + ":" + i);
        }
    }
}

输出结果：

所以得到以下结论：join方法必须在线程start方法调用之后调用才有意义。这个也很容易理解：如果一个线程都没有start，那它也就无法同步了。

三、源码解析

不多废话，直接上源码：

public final void join() throws InterruptedException {
        join(0);
    }

默认的join方法是传入一个0毫秒的，接下看实现：

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

先关注下方法修饰词，使用final修饰，表示此方法不能重写，无法覆盖，synchronized在JVM级别维护了线程的同步。接下看这个isAlive，我们去看注释：

/**
     * Tests if this thread is alive. A thread is alive if it has
     * been started and has not yet died.
     *
     * @return  <code>true</code> if this thread is alive;
     *          <code>false</code> otherwise.
     */
    public final native boolean isAlive();

线程只有started（启动）而且还没有销毁的时候isAlive这个状态才为true，换句话说，一个线程需要调用了start（）方法，而且没有死亡（阻塞的线程调用了interrupt()方法，或者线程执行完毕），在这中间的状态才是true，然后调用JNI的wait（）方法，使用等待-通知机制去进行线程间的交互。

public final native void wait(long timeout) throws InterruptedException;

本次实例中，我们也可以加上一行输出语句验证，结果和我们要的一样。

参考：https://blog.youkuaiyun.com/si444555666777/article/details/82347056