Java Thread中的join()方法解释

最新推荐文章于 2025-06-22 12:23:47 发布

原创最新推荐文章于 2025-06-22 12:23:47 发布 · 8.5k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#java

JAVA多线程专栏收录该内容

8 篇文章

订阅专栏

Java Thread类中的join()方法用于阻塞当前线程，等待指定线程执行完毕后再继续执行。join内部通过调用线程对象的wait()方法实现，释放持有锁，允许其他等待该锁的线程执行。在使用join()时需要注意InterruptedException的捕获。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Join作用

join是定义在Thread类中的方法，作用是阻塞当前线程的执行，等到被调用join的线程对象执行完毕才执行继续执行当前线程。在Java源码中的定义如下：

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

public final synchronized void join(long millis) throws InterruptedException

接下来我们先来看看join的简单使用，这样能更好的帮助理解：

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            System.out.println("执行" + Thread.currentThread().getName() + i);
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "thread");
    thread.start();
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程" + Thread.currentThread() + "执行结束");

    }

上面代码的输出结果将会是：

执行thread0
执行thread1
执行thread2
执行thread3
执行thread4
线程Thread[main,5,main]执行结束

所以我们可以看出，主线程执行到join的时候，会被阻塞直到thread这个子线程执行完才继续执行主线程，也就是说，thread.join()方法阻塞调用此方法的线程(callingthread)进入TIMED_WAITING状态，直到线程t完成，此线程再继续。

当我们再回到刚才join方法的源码时，发现最终是调用到

public final synchronized void join(long millis) throws InterruptedException

这个方法，它是无参那个方法的重载。这方法是个同步方法，锁对象是调用join的线程对象本身，为什么要加这个synchronized呢，继续往里看可以看到：

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

其实它内部是调用了该线程对象的wait方法，而我们知道，wait，notify这些方法必须在同步代码中调用，否则会抛出IllegalMonitorStateException异常，所以这里直接用了本身的线程对象，这也说明了一个问题，join()的执行肯定获得本线程对象锁。

到这里，join的用法其实也就这么简单，但是延伸一个问题，就是调用join时，会释放锁吗？如果会，释放的是哪个锁？是调用join时所处的线程所持有的锁还是thread1这个线程对象锁？

答案是：会释放锁，释放的是调用join的这个线程对象的锁。也就是说，本例子中调用thread.join()时，如果该句代码执行在以thread对象为锁的同步代码中，那么当cpu把执行权给了其他thread这个线程中时，该线程中如果也有以thread对象为锁的同步代码块，那么该代码块会获得锁并得到执行。我们从

public final synchronized void join(long millis) throws InterruptedException

的内部实现也可以看出来，因为调用的是该线程对象的wait方法，并且这个wait是包在以thread这个对象为锁的同步方法中的，我们知道执行wait方法是会释放锁的，不明白可看我另一篇wait与notify的文章，所以我们可以得出上述结论。接下来我们以一个例子来做验证：

public class JoinTest {

    Object lock = new Object();

    public void main() throws InterruptedException {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2(thread1);

        thread1.start();
        thread2.start();

        Thread.sleep(3000L);
        synchronized (thread1) {
            System.out.println("执行" + Thread.currentThread().getName() + "中的同步代码块");
        }
    }

    class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("开始执行" + Thread.currentThread().getName() + "...");
            try {
                while (true) {
                    System.out.println("执行" + Thread.currentThread().getName() + "中的同步代码块");
                    Thread.sleep(1000L);
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "被interrupt,此时该线程的interpret标记位为：" + Thread.interrupted());
            }
            System.out.println("结束执行" + Thread.currentThread().getName() + "！！！");
        }
    }

    class Thread2 extends Thread {
        private Thread1 thread1;

        public Thread2(Thread1 thread1) {
            this.thread1 = thread1;
        }

        @Override
        public void run() {
            System.out.println("开始执行" + Thread.currentThread().getName() + "...");
            try {
                synchronized (thread1) {
                    thread1.join();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束执行" + Thread.currentThread().getName() + "！！！");
        }
    }
}

本示例中，定义了2个子线程，Thread1中做了一个无限循环操作，Thread2中调用了Thread1线程对象的join方法，这样的话，thread2就得等到thread1执行完才能继续执行。这时thread2线程中，调用thread1.join()方法是在同步代码块中。紧接着我们在3秒后在主线程中也用这个对象作为锁执行一段代码来看一下结果：

开始执行Thread-0...
执行Thread-0中的同步代码块
开始执行Thread-1...
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行main中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块

    ...

这时候我们可以很清楚的看到，在thread2执行到thread1.join()方法时，如果thread1这个对象锁如果没有被释放的话，主线程中执行main中的同步代码块这段代码是执行不到的，但是我们看到结果确实执行到了，这时候我们可以大胆的说，当thread2中调用thread1.join()方法时，会释放thread1这个对象锁。我们也可以做一个小改动来验证一下，如果我们这时候把主线程和thread2线程中的同步代码块的锁都换成别的对象的话，结果将是thread1线程一直执行，而主线程中的执行main中的同步代码块这段代码是永远得不到执行的。我们来验证一下：

package com.lianwenhong;

public class JoinTest {

    Object lock = new Object();

    public void main() throws InterruptedException {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2(thread1);

        thread1.start();
        thread2.start();

        Thread.sleep(3000L);
        synchronized (lock) {
            System.out.println("执行" + Thread.currentThread().getName() + "中的同步代码块");
        }
    }

    class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("开始执行" + Thread.currentThread().getName() + "...");
            try {
                while (true) {
                    System.out.println("执行" + Thread.currentThread().getName() + "中的同步代码块");
                    Thread.sleep(1000L);
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "被interrupt,此时该线程的interpret标记位为：" + Thread.interrupted());
            }
            System.out.println("结束执行" + Thread.currentThread().getName() + "！！！");
        }
    }

    class Thread2 extends Thread {
        private Thread1 thread1;

        public Thread2(Thread1 thread1) {
            this.thread1 = thread1;
        }

        @Override
        public void run() {
            System.out.println("开始执行" + Thread.currentThread().getName() + "...");
            try {
                synchronized (lock) {
                    thread1.join();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束执行" + Thread.currentThread().getName() + "！！！");
        }
    }
}

输出的结果：

开始执行Thread-0...
开始执行Thread-1...
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
执行Thread-0中的同步代码块
    ...

结局正是我们所预料的那样。

还有一个值得我们注意的是，在我们查看源码的时候会发现，join()方法还会抛出一个InterruptedException，所以我们在使用thread.join()方法的时候需要注意捕获这个异常。这个异常的抛出是因为有可能别的线程会调用thread2.interrupt()方法，具体原因及作用我们在interrupt这篇笔记中说。

至此我们总结：
1.join是定义在Thread类中的方法，作用是阻塞当前线程的执行，等到被调用join的线程对象执行完毕才执行继续执行当前线程。
2.当thread.join()被调用时，如果调用的线程中持有了thread对象锁会被释放。

希望本文章能对Thread中的join()还不熟悉的朋友有点参考意义。