详解java Thread中的join方法

join()方法作用与原理

1. join()的作用
2. join()的原理
3. 总结

join()的作用

​ join()是 Thread 类中的一个方法，当我们需要让线程按照自己指定的顺序执行的时候，就可以利用这个方法。Thread.join()方法表示调用此方法的线程被阻塞，仅当该方法完成以后，才能继续运行。

作用于 main( )主线程时，会等待其他线程结束后再结束主线程。

示例

public class TestJoin {

    static int count=0;

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


        Thread t1 = new Thread(()->{
            System.out.println("Thread t1 run");
            count=10;
        });

        t1.start();
        t1.join();//若把这一行注释掉，则打印的count为0

        System.out.println("count="+count);
    }
}

此时的结果为：

Thread t1 run
count=10

说明在调用t1.join( )方法以后，main()的线程被阻塞，等到t1线程完成以后，main()线程再结束。

join()方法的原理

主要两点，线程如何被阻塞，线程又是如何被唤醒

join()方法是Thread类中的，所以我们可以直接查看源码，找到join()方法，如下。

还有另外一个重载的方法，不过实际上调用的就是下图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);//这里的wait调用的本地方法。
        }
    } else {//等待一段指定的时间
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

​ 从源码来看，实际上join方法就是调用了wait方法来使得线程阻塞，一直到线程结束运行。注意到，join方法前的synchronized修饰符，它相当于：

public final void join(long millis){
	synchronized(this){
        //代码块
    }
}

​ 也就是说加锁的对象即调用这个锁的线程对象，在main()方法中即为t1，持有这个锁的是主线程即main()方法，也就是说代码相当于如下：

//t1.join()前的代码
synchronized (t1) {
	// 调用者线程进入 t1 的 waitSet 等待, 直到 t1 运行结束
	while (t1.isAlive()) {
		t1.wait(0);
	}
}
//t1.join()后的代码

也因此主线程进入等待队列，直到t1线程结束。

wait 方法被调用以后，是让持有锁的线程进入等待队列，即主线程，因此 t1 线程并不会被阻塞。

那么问题在于，这里只看到了wait方法，却并没有看到notify或者是notifyAll方法，那么主线程在那里被唤醒呢。

这里参考jvm的代码：

static void ensure_join(JavaThread* thread) {

	Handle threadObj(thread, thread->threadObj());

	ObjectLocker lock(threadObj, thread);

	hread->clear_pending_exception();

	//这一句中的TERMINATED表示这是线程结束以后运行的
	java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);

    //这里会清楚native线程，isAlive()方法会返回false
    java_lang_Thread::set_thread(threadObj(), NULL);

	//thread就是当前线程，调用这个方法唤醒等待的线程。
	lock.notify_all(thread);

	hread->clear_pending_exception();

}

​ 其实是jvm虚拟机中存在方法lock.notify_all(thread)，在t1线程结束以后，会调用该方法，最后唤醒主线程。

​ 所以简化一下，流程即：

总结

要注意的其实就两点：

1. wait方法是使持有锁的线程进入等待队列，所以主线程会阻塞。
2. 唤醒进程的方法位于jvm中，在线程（调用join方法的线程）结束后主线程被调用。