实现线程自定义顺序执行——join()解析

待我称王封你为后i 2021-09-29 10:40 234阅读 0赞

### 【问题】 ###

现在有 T1、T2、T3 三个线程，你怎样保证 T2 在 T1 执行完后执行，T3 在 T2 执行完后执行？

要保证 T1、T2、T3 三个线程顺序执行，可以利用 Thread 类的 join 方法。Thread 类中的 join 方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。当我们调用某个线程的这个方法时，这个方法会挂起调用线程，直到被调用线程结束执行，调用线程才会继续执行。

--------------------

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

分析源码得到：

1、如果 join 方法传参为 0 的话，则会调用 isAlive () 方法（判断进程是否存活），一直检测线程是否存活（执行完毕）, 如果存活就调用 wait 方法，一直阻塞。

2、如果参数为负数，则直接报错：“timeout value is negative”

3、如果参数大于 0，则 while 里面一直判断线程是否存活，存活的话就一直判断当前线程执行的时间并与计算还需要等待多久时间，最后如果等待时间小于等于 0 就跳出循环，否则就继续 wait

--------------------

如果 A 线程中调用 B 线程的 join (10)，则表示 A 线程会等待 B 线程执行 10 毫秒，10 毫秒过后，A、B 线程并行执行。

所以，**在join中的while循环中的delay和wait，都是针对A线程的**

需要注意的是，jdk 规定，join (0) 的意思不是 A 线程等待 B 线程 0 秒，而是 A 线程等待 B 线程无限时间，直到 B 线程执行完毕，即 join (0) 等价于 join ()。

--------------------

### 实现代码： ###

public class OrderThread { 
        public static void main(String[] args) { 
            myThread t1,t2,t3 = null;
            try { 
                t1 = new myThread();
                t2 = new myThread();
                t3 = new myThread();
                t1.start();
                t1.join();
                t2.start();
                t2.join();
                t3.start();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            System.out.println("main is over ==================");
        }
    }
    
    class myThread extends Thread { 
        @Override
        public void run() { 
            int i = 1;
            while (i<10) { 
                System.out.println(Thread.currentThread() + " is doing " + i);
                i++;
            }
            System.out.println(Thread.currentThread() + " + is over *****************");
        }
    }

--------------------

### 执行结果： ###

Thread\[Thread-0,5,main\] is doing 1  
Thread\[Thread-0,5,main\] is doing 2  
Thread\[Thread-0,5,main\] is doing 3  
Thread\[Thread-0,5,main\] is doing 4  
Thread\[Thread-0,5,main\] is doing 5  
Thread\[Thread-0,5,main\] is doing 6  
Thread\[Thread-0,5,main\] is doing 7  
Thread\[Thread-0,5,main\] is doing 8  
Thread\[Thread-0,5,main\] is doing 9  
Thread\[Thread-0,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
Thread\[Thread-1,5,main\] is doing 1  
Thread\[Thread-1,5,main\] is doing 2  
Thread\[Thread-1,5,main\] is doing 3  
Thread\[Thread-1,5,main\] is doing 4  
Thread\[Thread-1,5,main\] is doing 5  
Thread\[Thread-1,5,main\] is doing 6  
Thread\[Thread-1,5,main\] is doing 7  
Thread\[Thread-1,5,main\] is doing 8  
Thread\[Thread-1,5,main\] is doing 9  
Thread\[Thread-1,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
main is over ==================  
Thread\[Thread-2,5,main\] is doing 1  
Thread\[Thread-2,5,main\] is doing 2  
Thread\[Thread-2,5,main\] is doing 3  
Thread\[Thread-2,5,main\] is doing 4  
Thread\[Thread-2,5,main\] is doing 5  
Thread\[Thread-2,5,main\] is doing 6  
Thread\[Thread-2,5,main\] is doing 7  
Thread\[Thread-2,5,main\] is doing 8  
Thread\[Thread-2,5,main\] is doing 9  
Thread\[Thread-2,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

可以看到，thread0，thread1，thread2是按照顺序执行完成的，关于"main is over====" 的顺序，一会解释

--------------------

如果未加join函数  
执行结果（不唯一）：  
main is over ==================  
Thread\[Thread-0,5,main\] is doing 1  
Thread\[Thread-2,5,main\] is doing 1  
Thread\[Thread-1,5,main\] is doing 1  
Thread\[Thread-2,5,main\] is doing 2  
Thread\[Thread-2,5,main\] is doing 3  
Thread\[Thread-2,5,main\] is doing 4  
Thread\[Thread-0,5,main\] is doing 2  
Thread\[Thread-2,5,main\] is doing 5  
Thread\[Thread-2,5,main\] is doing 6  
Thread\[Thread-2,5,main\] is doing 7  
Thread\[Thread-2,5,main\] is doing 8  
Thread\[Thread-2,5,main\] is doing 9  
Thread\[Thread-2,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
Thread\[Thread-1,5,main\] is doing 2  
Thread\[Thread-0,5,main\] is doing 3  
Thread\[Thread-0,5,main\] is doing 4  
Thread\[Thread-1,5,main\] is doing 3  
Thread\[Thread-0,5,main\] is doing 5  
Thread\[Thread-1,5,main\] is doing 4  
Thread\[Thread-0,5,main\] is doing 6  
Thread\[Thread-0,5,main\] is doing 7  
Thread\[Thread-1,5,main\] is doing 5  
Thread\[Thread-0,5,main\] is doing 8  
Thread\[Thread-0,5,main\] is doing 9  
Thread\[Thread-1,5,main\] is doing 6  
Thread\[Thread-0,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
Thread\[Thread-1,5,main\] is doing 7  
Thread\[Thread-1,5,main\] is doing 8  
Thread\[Thread-1,5,main\] is doing 9  
Thread\[Thread-1,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

这次thread0,1,2的顺序是不确定的，但是main is over======是确定放在第一位的。

### 说明： ###

**说明1. A线程调用B函数的join函数，那么谁是A线程，谁是B线程**

在代码中有如下

`t1.join()`  
`t2.join()`

实际上，t1，t2都属于B线程，而main函数所在的main线程才是A线程，所以前面所说的A调用B的join，则A会等待B执行一段时间，在继续执行A，正常的情况下，main 线程是由 java 虚拟机在启动的时候创建的。main 方法开始执行的时候，主线程已经创建好并在运行了。而main线程与其他用户线程相比，是没有特别之处的，当main线程结束之后，其他用户线程依旧可以继续执行，而不必要在main线程的声明周期内执行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

--------------------

这样其实是很合理的，按照操作系统的理论，进程是资源分配的基本单位，线程是 CPU 调度的基本单位。对于 CPU 来说，其实并不存在 java 的主线程和子线程之分，都只是个普通的线程。进程的资源是线程共享的，只要进程还在，线程就可以正常执行，换句话说线程是强依赖于进程的。也就是说，线程其实并不存在互相依赖的关系，一个线程的死亡从理论上来说，不会对其他线程有什么影响。

--------------------

这样就可以解释刚刚main is over=====的顺序问题

不存在join的时候，main函数是最先执行完成的，虽然已经使用start，但是线程**调用start函数只是让当前线程进入就绪状态**，当CPU时间片空闲的时候，才会执行这个线程，但是main线程已经在执行，所以main线程在没有join总是在第一的，也就是main线程最先结束。

存在join的时候，因为在main线程中调用t1,t2线程的join函数，所以要等待t1，t2执行结束，所在main is over======是在这两个线程执行结束之后才继续执行的，而t3是最后一个

--------------------

**说明2. join和start的顺序**

t1.start();
                t1.join();
                t2.start();
                t2.join();

和

t1.start();
    			t2.start();
                t1.join();            
                t2.join();

上面两种方式，执行的结果一致吗  
答案是：不一致

--------------------

因为start函数是让当前线程进入就绪状态，当t1，t2都调用了start的时候，二者就都进入了就绪状态，这个时候main线程在调用二者的join函数，就是说main线程会等你们执行完成，但是谁先谁后，就是由CPU调度了。所以t1，t2的顺序不确定，但是整体是在t3和main之前的

结果（不唯一）如下：  
Thread\[Thread-1,5,main\] is doing 1  
Thread\[Thread-0,5,main\] is doing 1  
Thread\[Thread-1,5,main\] is doing 2  
Thread\[Thread-0,5,main\] is doing 2  
Thread\[Thread-0,5,main\] is doing 3  
Thread\[Thread-0,5,main\] is doing 4  
Thread\[Thread-0,5,main\] is doing 5  
Thread\[Thread-0,5,main\] is doing 6  
Thread\[Thread-0,5,main\] is doing 7  
Thread\[Thread-0,5,main\] is doing 8  
Thread\[Thread-0,5,main\] is doing 9  
Thread\[Thread-1,5,main\] is doing 3  
Thread\[Thread-0,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
Thread\[Thread-1,5,main\] is doing 4  
Thread\[Thread-1,5,main\] is doing 5  
Thread\[Thread-1,5,main\] is doing 6  
Thread\[Thread-1,5,main\] is doing 7  
Thread\[Thread-1,5,main\] is doing 8  
Thread\[Thread-1,5,main\] is doing 9  
Thread\[Thread-1,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
main is over ==================  
Thread\[Thread-2,5,main\] is doing 1  
Thread\[Thread-2,5,main\] is doing 2  
Thread\[Thread-2,5,main\] is doing 3  
Thread\[Thread-2,5,main\] is doing 4  
Thread\[Thread-2,5,main\] is doing 5  
Thread\[Thread-2,5,main\] is doing 6  
Thread\[Thread-2,5,main\] is doing 7  
Thread\[Thread-2,5,main\] is doing 8  
Thread\[Thread-2,5,main\] is doing 9  
Thread\[Thread-2,5,main\] + is over \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

--------------------

说明3. 能否使用setPriority代替join函数

答案：不可以

// t1.setPriority(Thread.MIN_PRIORITY);1
                // t2.setPriority(Thread.NORM_PRIORITY);5
                // t3.setPriority(Thread.MAX_PRIORITY);10

thread创建的线程默认的优先级是5，优先级一共分为1-10,10个等级，但是即便一个线程设置为最高优先级，也不一定最先执行，只能说会尽量优先，因为调度算法不仅仅考虑优先级的，所以通过这种方式，只能说几率比较大，而不是百分百。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/6bd3794fee21464fbbf702625147237a.png