Java线程中的join()方法

对于Java中的join()方法的描述，我们首先来看下源码当中的解释

image.png

从源码当中的描述，我们只能知道join方法的作用是让线程陷入等待。其中可以传递以毫秒为单位的等待时间参数，如果传递参数为0，则线程会一直等待。

其实对于join方法，网上有很多解释，大都是只说如何使用，并没有对join当中的实现进行分析。
因此，在此结合网上的各种说法，对线程中的join方法进行源码分析，同时也记录自己的学习过程。

首先先来了解join方法如何使用，以及它的作用。
为了更有对比性的展示，首先来个简单并正常使用（不使用join）情况的多线程程序：

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Counter counter = new Counter();

        Thread tA = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.printA();
            }
        });

        Thread tB = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.printB();
            }
        });

        Thread tC = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.printC();
            }
        });

        tA.start();
        tB.start();
        tC.start();
    }

    static class Counter {
        
        public void printA() {
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("A");
            }
        }

        public void printB() {
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("B");
            }
        }

        public void printC() {
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("C");
            }
        }
    }
}

这个程序只是创建了三个线程，然后进行调用。程序结果如下：

image.png

可以看到，结果是三个线程都在执行自己的方法，各自线程互不干扰。

那么在此基础上，在调用tA.start()之后，再调用join()，再看运行结果：

image.png
image.png

可以看到，tA.start()当中的内容都执行完后，才轮到后面的tB和tC线程执行。
这个结果便是网上最常说的 “t.join()方法会使所有线程都暂停并等待t的执行完毕后再执行”

但如果看过源码就知道，这种说法是十分片面的
请看join的源码：

    /**
     * 解释：最多等待{@code millis}毫秒，以使该线程死亡。{@code 0} 超时意味着永远等待
     * Waits at most {@code millis} milliseconds for this thread to
     * die. A timeout of {@code 0} means to wait forever.
     */
    public final void join(long millis)
    throws InterruptedException {
        synchronized(lock) {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

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

通过源码了解，join之所以可以实现线程等待是因为调用wait方法。

那么对于线程不够了解的朋友就可能会问：在本文的示例中是tA.join()，而join中又调用了wait。那么不是让tA执行的线程陷入等待了吗，那不就是和网上的说法“让tA线程执行完，再执行其他线程”完全不一致了？

如果你有这样的疑问的话，说明你对wait方法也不够了解。
来看下wait方法的源码注释解释：

image.png

从wait方法的方法注释可以看到，wait方法会让当前线程陷入等待。注意，是当前线程！

那么我们再回头看下示例，在执行tA.join()这句代码的时候，当前线程是谁？
没错，是main主线程，而不是tA执行的线程。
tA执行的线程和main线程同时都在执行，而调用执行A.join()这句代码确确实实是在main主线程当中执行的。

因此在tA.join()当中的wait(0)方法是让main线程陷入了无尽的等待中。正是因为如此，在tA.join()之前的代码都会正常从上往下执行，而在tA.join()之后的代码都随着main线程陷入等待而无法继续执行。这样便达到了网上说的 “t.join()方法会使所有线程都暂停并等待t的执行完毕后再执行”。

到此，关于join的讲解尚未结束。之前有说到，join方法中调用wait(0)让当前线程陷入无尽的等待。那么有wait等待就会有相应的notify或者notifyAll唤醒，那么唤醒的地方又在哪里？

这个问题我也跟踪过join的方法，但始终发现不了在哪里唤醒等待的线程。所以在此引用网上的结论：join源码中，只会调用wait方法，并没有在结束时调用notify，这是因为线程在die的时候会自动调用自身的notifyAll方法，来释放所有因为该锁陷入等待的资源和锁。

#thread.cpp
//调用join后，是在JVM当中调用该方法自动唤醒线程
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
  ...
  // 这个方法入口
  ensure_join(this);
  ...
}

static void ensure_join(JavaThread* thread) {
  ...
  ObjectLocker lock(threadObj, thread);
  ...
  //唤醒等待在thread对象上的线程
  lock.notify_all(thread);
  ...
}

#ObjectSynchronizer.hpp
void notify_all(TRAPS)      { 
  ObjectSynchronizer::notifyall(_obj, CHECK); 
}

参考：https://blog.csdn.net/weixin_41083377/article/details/114598071