【JavaSE专栏83】线程插队，一个线程在另一个线程执行特定任务之前先执行

布满荆棘的人生 2023-10-14 21:46 11阅读 0赞

> **作者主页**：[Designer 小郑][Designer]  
> **作者简介**：3年JAVA全栈开发经验，专注JAVA技术、系统定制、远程指导，致力于企业数字化转型，CSDN学院、蓝桥云课认证讲师。  
> **主打方向**：Vue、SpringBoot、微信小程序

本文讲解了 Java 中线程插队的语法和应用场景，并给出了样例代码。线程插队是指一个线程在另一个线程执行特定任务之前先执行，插队线程会阻塞等待目标线程执行完特定任务，然后再继续执行。

#### 目录 ####

*  一、什么是线程插队
 *  二、什么情况会发生线程插队
 *  三、模拟线程插队
 *  四、线程插队面试题
 *  五、总结

![在这里插入图片描述][1da108b7cadc45e58e4e7818ec7f588d.png_pic_center]

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

## 一、什么是线程插队 ##

**线程插队是指一个线程（称为插队线程）在另一个线程（称为目标线程）执行特定任务之前先执行**。

**插队线程会阻塞等待目标线程执行完特定任务，然后再继续执行**。

线程插队常常使用线程的 `join` 方法来实现，`join` 方法可以将一个线程合并到当前线程中，使得当前线程等待目标线程执行完毕后再继续执行。

以下是一个简单的示例代码，演示了线程插队的使用，请同学们复制到本地执行。

public class JoinExample {
        
        public static void main(String[] args) {
        
            Thread targetThread = new Thread(new TargetRunnable());
            Thread joinThread = new Thread(new JoinRunnable(targetThread));
    
            targetThread.start();
            joinThread.start();
        }
    
        static class TargetRunnable implements Runnable {
        
            @Override
            public void run() {
        
                System.out.println("Target thread is running...");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("Target thread finished.");
            }
        }
    
        static class JoinRunnable implements Runnable {
        
            private final Thread targetThread;
    
            public JoinRunnable(Thread targetThread) {
        
                this.targetThread = targetThread;
            }
    
            @Override
            public void run() {
        
                System.out.println("Join thread is running...");
                try {
        
                    targetThread.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("Join thread finished.");
            }
        }
    }

在上述示例中，创建了两个线程：`targetThread` 和 `joinThread`。

`targetThread` 是目标线程，它会在执行过程中等待一段时间后结束。

`joinThread` 是插队线程，它会调用 `targetThread.join()` 方法来插队等待 `targetThread` 执行完毕。

> 运行代码后，可以观察到插队线程会在目标线程执行完特定任务后才继续执行。

![在这里插入图片描述][5cb43f7efa3e455c9c983c7aeb9737b8.png_pic_center]

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

## 二、什么情况会发生线程插队 ##

线程插队通常在以下  4 4 4 类情况下发生，请同学们认真学习。

1.  **主线程等待子线程完成**：当主线程需要等待子线程执行完毕后再继续执行时，可以使用线程插队的方式，主线程会调用子线程的 `join()` 方法来插队等待子线程执行完毕。
2.  **线程依赖关系**：当存在多个线程的执行顺序有依赖关系时，可以使用线程插队来保证特定的执行顺序，例如线程  A A A 需要等待线程  B B B 执行完毕后才能继续执行，可以在线程  A A A 中调用线程  B B B 的 `join()` 方法来插队等待。
3.  **线程协作**：当多个线程需要协作完成某个复杂的任务时，可以使用线程插队来控制各个线程的执行顺序，通过使用 `join()` 方法，可以使得各个线程按照指定的顺序逐个执行。
4.  **线程间的数据共享**：当多个线程需要共享某个数据结果时，可以使用线程插队来确保数据的正确性，例如线程  A A A 计算某个数据结果，线程  B B B 等待线程  A A A 计算完毕后读取该结果，可以在线程  B B B 中调用线程A的 `join()` 方法来插队等待。

> 线程插队是一种同步操作，会导致线程的阻塞。在使用线程插队时，需要谨慎考虑是否会引起死锁或线程间的竞争条件，正确使用线程插队可以提高线程的执行效率和保证数据的正确性。

![在这里插入图片描述][b4d8656d771f45cca9cd2f998b24e837.png_pic_center]

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

## 三、模拟线程插队 ##

下面是一个使用 Java 模拟线程插队的示例代码，请同学们复制到本地执行。

public class ThreadJoinExample {
        
    
        public static void main(String[] args) {
        
            Thread targetThread = new Thread(new TargetRunnable());
            Thread joinThread = new Thread(new JoinRunnable(targetThread));
            targetThread.start();
            joinThread.start();
        }
    
        static class TargetRunnable implements Runnable {
        
            @Override
            public void run() {
        
                System.out.println("Target thread is running...");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("Target thread finished.");
            }
        }
    
        static class JoinRunnable implements Runnable {
        
            private final Thread targetThread;
    
            public JoinRunnable(Thread targetThread) {
        
                this.targetThread = targetThread;
            }
    
            @Override
            public void run() {
        
                System.out.println("Join thread is running...");
                try {
        
                    targetThread.join();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("Join thread finished.");
            }
        }
    }

在示例代码中，创建了两个线程：`targetThread` 和 `joinThread`。

**`targetThread` 是目标线程**，它会在执行过程中等待一段时间后结束。

**`joinThread` 是插队线程**，它会调用 `targetThread.join()` 方法来插队等待 `targetThread` 执行完毕。

运行代码后，可以观察到插队线程会在目标线程执行完特定任务后才继续执行。

![在这里插入图片描述][d32190560de84780a37caee92d58ca5e.png_pic_center]

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

## 四、线程插队面试题 ##

> 问题：请使用Java编写一个程序，实现三个线程的插队执行。

1.  程序中有  3 3 3 个线程，分别为  A 、 B 、 C A、B、C A、B、C，按照  A − > B − > C A->B->C A−>B−>C 的顺序依次执行。
2.  每个线程打印输出自己的名字，并等待1秒后再执行下一个线程。
3.  程序运行结果应该为依次输出 `A` 、等待  1 1 1 秒、输出 `B`、等待  1 1 1 秒、输出 `C`。

public class ThreadJoinExample {
        
        public static void main(String[] args) {
        
            Thread aThread = new Thread(new MyRunnable("A"));
            Thread bThread = new Thread(new MyRunnable("B"));
            Thread cThread = new Thread(new MyRunnable("C"));
            
            try {
        
                aThread.start();
                aThread.join();
                
                bThread.start();
                bThread.join();
                
                cThread.start();
                cThread.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
        
        static class MyRunnable implements Runnable {
        
            private String name;
            
            public MyRunnable(String name) {
        
                this.name = name;
            }
            
            @Override
            public void run() {
        
                System.out.println(name);
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

我们创建了三个线程  A 、 B 、 C A、B、C A、B、C，并使用线程的 `join()` 方法实现了线程的插队。每个线程都打印输出自己的名字，并等待  1 1 1 秒后再执行下一个线程。

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

## 五、总结 ##

本文讲解了 Java 中线程插队的语法和应用场景，并给出了样例代码，在下一篇博客中，将讲解 Java 线程让步的问题。

![在这里插入图片描述][3a01dc60e62c415b812015851343f1c0.png_pic_center]

[Designer]: https://blog.csdn.net/qq_41464123
[1da108b7cadc45e58e4e7818ec7f588d.png_pic_center]: https://img-blog.csdnimg.cn/1da108b7cadc45e58e4e7818ec7f588d.png#pic_center
[5cb43f7efa3e455c9c983c7aeb9737b8.png_pic_center]: https://img-blog.csdnimg.cn/5cb43f7efa3e455c9c983c7aeb9737b8.png#pic_center
[b4d8656d771f45cca9cd2f998b24e837.png_pic_center]: https://img-blog.csdnimg.cn/b4d8656d771f45cca9cd2f998b24e837.png#pic_center
[d32190560de84780a37caee92d58ca5e.png_pic_center]: https://img-blog.csdnimg.cn/d32190560de84780a37caee92d58ca5e.png#pic_center
[3a01dc60e62c415b812015851343f1c0.png_pic_center]: https://img-blog.csdnimg.cn/3a01dc60e62c415b812015851343f1c0.png#pic_center