java多线程拾遗(三) 霸道的join()方法

骑猪看日落 2023-07-16 09:58 6阅读 0赞

#### 前言 ####

相信每个人都有被插队的经历，线程之间执行任务也是这样，总有线程爱插队，最骚的是Thread类中专门有这样一个方法来让其"插队"，那就是join方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70]  
`join()`方法的作用在于，如果在某个线程A中，另外一个线程B调用join()方法后，那么A需要在B执行完成之后，才可以继续执行任务。此时A线程的状态由运行态变为阻塞态。

另外，我们亦可以设置一个超时时间，让等待的线程最多等待多少秒就不等了。 如果设置0s，则代表永远等下去，直到插队的线程运行结束。

如果验证呢？我们看看jdk源码，下面是join()无参方法的源码，内部就是调用了`join(0)`方法。

// Waits for this thread to die.
       
        public final void join() throws InterruptedException {
        
            join(0);
        }

我们再来看看有参`join()`方法

/**
         * Waits at most {@code millis} milliseconds for this thread to 
         * die. A timeout of {@code 0} means to wait forever.
         *
    **/
        public final synchronized void join(long millis)
        throws InterruptedException {
        
        ....
        }

最多等待这么长时间，0代表永远等待，直到运行结束。

#### 使用join()方法来插队 ####

我们先实现`Runnable`接口，让其输出1到1000。

static class MyThread implements  Runnable
        {
        
            @Override
            public void run() {
        
                System.out.println(Thread.currentThread().getName()+"线程开始执行");
                for(int i=0;i<1000;i++)
                {
        
                    System.out.println("子线程输出:"+i);
                }
                System.out.println(Thread.currentThread().getName()+"线程执行完毕");
            }
        }

在main方法，即主线程中，创建子线程执行任务，并且循环输出1到100，当输出到50时，让子线程插队。

public static void main(String[] args) {
        
            Thread thread = new Thread(new MyThread(),"A");
    
            thread.start();
    
    
            for(int i=0;i<100;i++)
            {
        
                if(i==50)
                {
        
                    try {
        
                        thread.join();//插队
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                System.out.println("主线程输出:"+i);
            }
        }

**输出结果**

主线程输出:0
    主线程输出:1
    主线程输出:2
    主线程输出:3
    主线程输出:4
    主线程输出:5
    ...
    主线程输出:49
    A线程开始执行
    子线程输出:0
    ....
    子线程输出:997
    子线程输出:998
    子线程输出:999
    A线程执行完毕
    主线程输出:50
    主线程输出:51
    主线程输出:52
    ...
    主线程输出:97
    主线程输出:98
    主线程输出:99
    
    Process finished with exit code 0

可以看到，刚开始主线程持续输出,到i=50的时候，子线程插队，从而主线程进入阻塞状态，直到子线程输出完毕。

#### 总结 ####

join()方法真是"霸道"啊…

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70]: /images/20230528/a823846ff823413b95f0a72e0d69b839.png