java线程的join()方法的理解

• 例1：比如在线程B中调用了线程A的 join 方法，直到线程A执行完毕后，才会继续执行线程B。
• 例2：再比如我们做查询操作，总任务需要返回三个查询列表，那么主线程就需要等待这三个线程全部执行完并返回结果后才可以结束，这时就需要用到 join 方法。（具体例子可以看博客 “线程池怎么用(实例)“）
• 例3：某些情况、主线程中启用了子线程，如果子线程需要大量的算法，需要运算的时间较长，主线程可能会在子线程结束前就结束，这个时候如果想等待子线程结束后再结束主线程，可以使用join()方法。

/**例1**/
t.join();   //调用join方法，等待线程t执行完毕
t.join(1000); //等待 t 线程，等待时间是1000毫秒。

/**例3**/
public class JoinTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1= new Thread(()->{
            try {
                Thread.sleep(9000);//子线程处理中
                System.out.println("子线程处理完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        thread1.join();
        System.out.println("主线程结束");
    }
}

join源码解析

• Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever. 意思是等待一段时间直到这个线程死亡。超时0意味着永远等待。
• 从源码中我们可以看出来join方法的实现是通过wait，wait是一个Object提供的方法。当main线程调用 t.join 时，主线程会获得线程对象的锁（wait意味着拿到该对象的锁），调用该对象的 wait(time) ，直到该对象唤醒main线程。比如退出。这就意味着main 线程调用 t.join时，必须能够拿到线程t对象的锁。如果拿不到时无法wait的。

public class JoinTest {
    public static void main(String[] args) {
        Thread t=new Thread(new RunnableImpl());
        t.start();
        try {
            t.join(1000);
            System.out.println("join结束了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class RunnableImpl implements Runnable{

    @Override
    public void run() {
        try {
            System.out.println("开始sleep");
            Thread.sleep(1000);
            System.out.println("结束sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Override
public void run() {
    try {
        System.out.println("开始sleep");
        //Thread.sleep(1000);
        Thread.sleep(2000);
        System.out.println("结束sleep");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public class JoinTest {
    public static void main(String[] args) {
        long start=System.currentTimeMillis();
        Thread t=new Thread(new RunnableImpl());
        new MythreadTest(t).start();
        t.start();
        try {
            t.join(1000);
            System.out.println("join结束了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("时间："+(System.currentTimeMillis()-start));
    }
}

class RunnableImpl implements Runnable{

    @Override
    public void run() {
        try {
            System.out.println("开始sleep");
            //Thread.sleep(1000);
            Thread.sleep(2000);
            System.out.println("结束sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MythreadTest extends Thread{

    Thread thread;

    public MythreadTest(Thread thread){
        this.thread=thread;
    }

    @Override
    public void run() {
        holdThreadLock();
    }

    public void holdThreadLock(){
        synchronized (thread){
            System.out.println("拿到对象锁");

        try {
            Thread.sleep(9000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            System.out.println("释放对象锁");
        }
    }
}