Java线程中的join()方法

发量状况目前良好

已于 2025-02-07 12:56:48 修改

阅读量342

点赞数 6

文章标签： java

于 2025-01-10 22:19:48 首次发布

本文链接：https://blog.csdn.net/m0_49227604/article/details/145065179

版权

！！！为方便理解，文中会一直用“线程A”、“线程B”来举例说明。

1 join()方法的作用：

在线程A中通过线程B去调用此方法，则会使线程A进入阻塞状态，直到线程B执行结束后，线程A才会结束阻塞状态继续执行。

2 join()方法的使用场景（举例一个场景）：

当线程A需要获取到某些数据后才能继续执行，这时可以开辟线程B去执行获取数据的操作，并在线程A中通过线程B去调用join()方法，那么当线程B获取到数据后就可以结束线程，线程A可以根据线程B获取到的数据继续执行。

3 join()方法使用时是否释放同步锁？

join()方法源码 ↓

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

//join()方法主逻辑
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;
        }
    }
}

结论：

在join()方法的源码中，join()方法被synchronized修饰，且在同步方法中调用了wait()方法。因为wait()方法一定会阻塞当前线程并且释放线程的同步锁，所以join()方法并非不释放锁，而是其释放的并不是外层join()方法被调用时所在的线程掌握的锁（线程A的锁），而是释放的当前调用join()方法的线程掌握的锁（线程B的对象：非静态同步方法中默认同步监视器（锁）为当前线程类的对象）。

上述表达可能有些绕，可以结合下面的代码和说明进行理解~

public class JoinMethodTest {

    //自定义的对象锁obj
    private static final Object obj = new Object();

    public static void main(String[] args) {

        ThreadB threadB = new ThreadB("threadB", obj);
        ThreadA threadA = new ThreadA("threadA", obj, threadB);

        threadA.start();
        threadB.start();

    }
}

class ThreadA extends Thread {
    private String name;
    private Object obj;
    private ThreadB threadB;

    public ThreadA(String name, Object obj, ThreadB threadB) {
        this.name = name;
        this.obj = obj;
        this.threadB = threadB;
    }

    @Override
    public void run() {
        synchronized (obj) {  //① -> 不释放锁：obj
        //synchronized (threadB){  //② -> 释放锁：threadB
            for (int i = 1; i <= 10; i++) {
                if (i == 6) {
                    try {
                        threadB.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(name + "：" + i);
            }
        }
    }
}

class ThreadB extends Thread {
    private String name;
    private Object obj;

    public ThreadB(String name, Object obj) {
        this.name = name;
        this.obj = obj;
    }

    @Override
    public void run() {
        synchronized (obj) {
            method();
        }
    }

    private synchronized void method() {
        System.out.println("B线程中的method()方法执行了...");
        for (int i = 1; i <= 10; i++) {
            System.out.println(name + "：" + i);
        }
    }
}