JAVA多线程基础篇-join方法的使用

已于 2022-08-04 16:20:17 修改
阅读量8.2k 收藏 52
点赞数 6
分类专栏： 多线程 文章标签： java
于 2022-07-31 22:46:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33479841/article/details/126091931
版权
本文详细介绍了Java线程的join()方法，包括其使用方式、工作原理和注意事项。join()方法使得当前线程等待指定线程执行完毕后再继续，常用于线程间的同步。此外，还探讨了join()与sleep()的区别，以及interrupt()对join()的影响。在实际开发中，合理使用join()可以有效控制线程执行顺序，避免数据竞争问题。
摘要由CSDN通过智能技术生成

1.概述

join()是Thread类中的一个方法，它的作用是将当前线程挂起，等待其他线程结束后再执行当前线程，即当前线程等待另一个调用join()方法的线程执行结束后再往下执行。通常用于在main主线程内，等待其它调用join()方法的线程执行结束再继续执行main主线程。本文将探索join方法的使用方式和使用原理。

2.join方法使用

2.1 join()示意图

2.1.1线程运行示意图

在这里插入图片描述

上述案例示意图中，主线程A入栈运行，运行时创建子线程B和线程C执行任务，B线程或C线程调用join方法，阻塞当前线程A，B或C线程执行完成，A线程才会继续执行。

2.1.2案例代码

public class ThreadB extends Thread {

    public void run() {
        System.out.println("线程：" + Thread.currentThread().getName() + "休眠:10s");
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("线程：" + Thread.currentThread().getName() + "休眠结束");
    }

}

public class ThreadC extends Thread {

    public void run() {
        System.out.println("线程：" + Thread.currentThread().getName() + "休眠:1s");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("线程：" + Thread.currentThread().getName() + "休眠结束");
    }

}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程线程A开始运行。。。");
        ThreadB threadB = new ThreadB();
        threadB.setName("ThreadB");
        threadB.start();

        ThreadC threadC = new ThreadC();
        threadC.setName("ThreadC");
        threadC.start();

        threadB.join();

        System.out.println("主线程线程A结束运行");

    }
}

运行结果如下：
在这里插入图片描述
方法join的作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期的阻塞，等待线程x被销毁后再继续执行线程z后面的代码。

2.2 join方法原理

先看一下join()方法的源码，源码基于JDK 1.8，具体如下：

 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) {
           //判断线程是否存活，若为true，调用wait()方法阻塞
            while (isAlive()) {
                wait(0);
            }
        } else {
            //阻塞指定时间
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

由上述源码可知，join方法的底层实际上还是调用了wait()方法，通过wait()方法实现线程阻塞等待，那么这里有个问题，阻塞完成后，如何通知呢？我们知道调用wait阻塞的线程，需要notify()或者notifyAll来进行唤醒，这里并没有显式调用这两个方法，那是如何实现的呢？这里涉及一个知识：

在java中，Thread类线程执行完run()方法后，会自动执行notifyAll()方法。

具体的实现在HotSpot的源码中，有个ensure_join方法，大家感兴趣可查看。

2.3 注意事项

2.3.1 join方法被interrupt会异常

测试代码如下：

public class ThreadA extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append(i);
            String s = stringBuffer.toString();
        }
    }
}


public class ThreadB extends Thread {

    @SneakyThrows
    @Override
    public void run() {
        ThreadA threadA = new ThreadA();
        threadA.start();
        threadA.setName("ThreadA");
        threadA.join();
        System.out.println(Thread.currentThread().getName() + "运行完成！");
    }

}

public class ThreadC extends Thread {

    private ThreadB threadB;

    public ThreadC(ThreadB threadB) {
        this.threadB = threadB;
    }

    @Override
    public void run() {
        threadB.interrupt();
        System.out.println(Thread.currentThread().getName() + "运行结束！");
    }
}


public class Test {

    public static void main(String[] args) {
        ThreadB threadB = new ThreadB();
        threadB.start();
        threadB.setName("ThreadB");

        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (Exception e) {
            e.printStackTrace();
        }
        ThreadC threadC = new ThreadC(threadB);
        threadC.setName("ThreadC");
        threadC.start();
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
}

运行结果如下：
在这里插入图片描述
上述代码中，ThreadB 中创建了一个ThreadA执行，并让threadA.join()，又让线程ThreadC调用线程ThreadB的interrupt()方法来打断进程。由运行结果可知，方法join()与interrupt()相遇，会出现异常，而上述进程又未终止，说明ThreadA还在运行。

2.3.2 方法join(long)与sleep(long)的区别

由上述join方法的源码可知，在执行完wait(long)方法后，当前线程的锁被释放，那么其它线程就可以调用此线程中的同步方法。sleep(long)方法却不释放锁，也就意味着当线程调用sleep方法时，线程会被阻塞，其它线程只能等待获取锁。
测试代码如下：

public class ThreadA extends Thread {

    private ThreadB threadB;

    public ThreadA(ThreadB threadB) {
        this.threadB = threadB;
    }

    @Override
    public void run() {
        try {
            synchronized (threadB) {
                threadB.start();
                Thread.sleep(6000L);
                System.out.println(Thread.currentThread().getName() + "结束运行！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


public class ThreadB extends Thread {

    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始运行：" + System.currentTimeMillis());
        try {
            Thread.sleep(5000L);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束：" + System.currentTimeMillis());
    }

    public synchronized void print() {
        System.out.println(Thread.currentThread().getName() + "打印了时间：" + System.currentTimeMillis());
    }
}

public class ThreadC extends Thread {

    private ThreadB threadB;

    public ThreadC(ThreadB threadB) {
        this.threadB = threadB;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始运行！");
        threadB.print();
        System.out.println(Thread.currentThread().getName() + "运行完成！");
    }
}


public class Test {
    public static void main(String[] args) {
        ThreadB threadB = new ThreadB();
        threadB.setName("ThreadB");
        ThreadA threadA = new ThreadA(threadB);

        threadA.start();
        threadA.setName("ThreadA");
        try {
            Thread.sleep(1000L);
            ThreadC threadC = new ThreadC(threadB);
            threadC.setName("ThreadC");
            threadC.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：
在这里插入图片描述
由上述代码可知，线程ThreadA调用sleep方法一直持有线程ThreadB对象的锁，时间达到6s，所以线程ThreadC只能在ThreadA时间达到6s后释放线程ThreadB的锁时，才可以调用ThreaB的同步方法print()。由上述现象可知，Thread.sleep(long)不释放锁。
修改上述ThreadA中的代码，验证join()方法释放锁，具体代码如下：

public class ThreadA extends Thread {

    private ThreadB threadB;

    public ThreadA(ThreadB threadB) {
        this.threadB = threadB;
    }

    @Override
    public void run() {
        try {
            synchronized (threadB) {
                threadB.start();
                //Thread.sleep(6000L);
                threadB.join();
                System.out.println(Thread.currentThread().getName() + "结束运行！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：
在这里插入图片描述
由上述运行结果可知，在线程ThreadA中调用ThreadB的join()方法，线程ThreadC在ThreadB未执行完成后，获取到了锁，执行了同步方法print()，说明join(long)方法会释放锁。

2.3.3 join()方法后的代码提前执行

案例代码如下：

public class ThreadA extends Thread {

    private ThreadB threadB;

    public ThreadA(ThreadB threadB) {
        this.threadB = threadB;
    }

    @Override
    public void run() {
        try {
            synchronized (threadB) {
                System.out.println(Thread.currentThread().getName() + "开始运行！");
                Thread.sleep(5000L);
                System.out.println(Thread.currentThread().getName() + "结束运行!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadB extends Thread {

    public synchronized void run() {
        System.out.println(Thread.currentThread().getName() + "开始运行：" + System.currentTimeMillis());
        try {
            Thread.sleep(5000L);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束：" + System.currentTimeMillis());
    }
}


public static void main(String[] args) {
        try {
            ThreadB threadB = new ThreadB();
            ThreadA threadAA = new ThreadA(threadB);
            threadAA.start();
            threadAA.setName("threadAA");
            threadB.setName("threadB");
            threadB.start();
            threadB.join(2000);
            System.out.println(Thread.currentThread().getName() + "结束运行！");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

运行结果如下：
在这里插入图片描述
出现上述情况的原因如下：

1.b.join(2000)方法先抢到threadB锁，然后将锁释放；
2.ThreadA抢到锁，打印：threadAA开始运行，并且sleep 5s;
3.ThreadA打印：threadAA运行结束，并释放锁；
4.此时join(2000)和ThreadB争抢锁，而join(2000)再次抢到锁，发现时间已过，释放锁后打印：main运行结束；
5.ThreadB抢到锁打印ThreadB开始运行；
6.5s后ThreadB打印：threadB运行结束。

2.3.4 Thread.currentThread().join()方法

若调用这个方法，当前线程将一直被阻塞，无法退出，开发中因谨慎使用。修改2.1.2节中测试代码为：

public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程线程A开始运行。。。");
        ThreadB threadB = new ThreadB();
        threadB.setName("ThreadB");
        threadB.start();

        ThreadC threadC = new ThreadC();
        threadC.setName("ThreadC");
        threadC.start();

        //threadB.join();
        Thread.currentThread().join();

        System.out.println("主线程线程A结束运行");
}

出现运行结果如下：
在这里插入图片描述

3.小结

1.join()方法主要使用场景是一个线程需要等待另线程的运行结果，需要阻塞当前线程等待；
2.join()和join(long)的主要区别是：join(long)阻塞指定时间；join()一直阻塞，直至线程被销毁；
3.join() 方法被interrupt()会抛出异常，join()方法使用后会释放锁，sleep(long)方法却不释放锁；
4.Thread.currentThread().join()方法会一直阻塞线程。

4.参考文献

1.https://www.jb51.net/article/216689.htm
2.《JAVA多线程编程核心技术》-高洪岩著

程可爱
关注
  • 6
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 多线程join方法的使用
抛弃幻想，准备斗争
03-23 674
在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束，这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。 方法join():等待线程对象销毁。 作用：使所属的线程对象x正常执行run()方法中的任务，而使线程z进行无限制的阻塞， 等待线程x销毁后再继续执行线程z后面...
Java多线程篇--原子包、阻塞队列和并行流
rqc112233的专栏
06-09 262
在之前的文章中，已经发布了常见的面试题，这里我花了点时间整理了一下对应的解答，由于个人能力有限，不一定完全到位，如果有解答的不合理的地方还请指点，在此谢过。 本文主要描述的是java多线程中提供的一些常用框架atomic、阻塞队列、并行流。原子类在某些场景下能够提高性能，避免使用锁。阻塞队列完成的是生产者消费者模型，这个在很多场景会使用到，包括线程池里面的一个重要参数就是阻塞队列。并行流结合lambda表达式能够改变我们的平时代码风格，但要注意的是需要关注一下线程安全问题。如果对java多线程感兴趣的同学
java多线程join()方法的作用和实现原理
叶新东老师的博客
07-04 3104
join() 方法的作用 这个方法的作用是先将当前线程挂起，待其他线程结束后在执行当前线程的代码； 应用场景 比如有三个人小红、小李、小王， 三个人相约一起去酒店吃饭，菜已经点好了，三个人从不同的地方出发，只有三个人都到了酒店之后才会开始上菜；那么这三个人就分别代表三个线程，这三个线程执行完之后才会执行 “上菜” 的代码逻辑， 代码示例 package com.Lock; public class ConutDownLatchDemo_1 implements Runnable ...
Java 中的 Thread.join() 方法详解
最新发布
csdn_life18的博客
06-07 1338
在多线程编程中，线程的管理和协调是一个重要课题。Java 提供了多种机制来实现线程之间的协调，其中之一就是方法。join()方法允许一个线程等待另一个线程完成，这在很多场景中是非常有用的。例如，当我们需要确保某个任务在继续之前必须先完成另一个任务时，join()方法就是一个很好的选择。
java join的用法
anhuixiaozi的专栏
09-13 1万+
join的用法，先看几个例子在说。 程序1：public class ThreadTest implements Runnable {  public static int a = 0; public synchronized void inc() {  a++; }  public void run() {  for (int i = 0; i    inc();  } 
线程中join()的用法
ZHAOXING_ME的博客
01-21 1万+
转载来源：线程中join()的用法     Thread中，join（）方法的作用是调用线程等待该线程完成后，才能继续用下运行。 public static void main(String[] args) throws InterruptedException { System.out.println("main start"); Threa...
Java多线程join()
IsResultXaL的博客
11-08 803
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 也可以在调用join()时带上一个超时的参数，这样如果目标线程A在这段时间到期时还没有结束的话，join()方法返回,执行线程B，这个时候AB两个线程一起执行。 并且对join()方法的调用可以被中断，做法是在调用
java多线程中的join
renjingkai的博客
08-08 331
参考链接
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
java多线程Thread的实现方法代码详解
08-28
现代的多线程编程中，通常使用标志变量或`interrupt()`方法来优雅地停止线程。 4. **interrupt()** `interrupt()`方法用于中断线程。当调用一个线程的`interrupt()`方法时，会设置线程的中断标志位。线程在执行...
多线程基础篇-05
qqq932778763的博客
05-09 509
文章目录 ` 第五章 Thread的join方法及中断interupt方法详解 文章目录文章目录一、Thread的join方法二、中断interupt方法 一、Thread的join方法 1、join()方法的作用就是让当前线程等待被join的线程执行结束之后再运行当前线程。 2、join()方法需要在start方法之后调用。 3、join()方法和join(time) 如下案例中，当前线程是main线程，被join的是t1和t2线程，所有main线程会等待t1线程和t2线程执行完死掉再执行。 publ
Java多线程之基础篇(二).docx
04-16
Java 多线程是Java语言中的一个重要特性，...总的来说，Java多线程编程涉及许多概念和机制，包括线程创建、同步、通信、异常处理等。理解和熟练掌握这些知识点是开发高并发应用的基础，也是提升Java程序员技能的关键。
Java中多线程的join方法详解
mercedes_benz
07-06 2844
因为子线程执行需要2秒，所以在指定时间内子线程没有执行完成，主线程解除阻塞后继续执行。因为子线程执行需要一定时间（2秒），所以主线程会暂时被阻塞，直到子线程执行完成。方法的线程会等待被加入线程执行完成，然后再继续执行自己的后续操作。方法是用于将一个线程加入到当前线程，并且让当前线程等待被加入线程执行完成后再继续执行。毫秒的时间，如果在指定时间内被加入线程没有执行完成，那么当前线程会解除阻塞继续执行。在上述示例中，主线程创建并启动了一个子线程，并调用子线程的。方法的线程会等待被加入线程。
Java多线程join()方法
weixin_54963748的博客
01-03 3375
Java多线程join()方法
JAVA多线程Join
seekray的博客
07-11 203
Join相当于插队的操作 主线程 和 分线程 属于并发线程 算是多个线程对象 如果使用Join 使得一个线程优先执行其余阻塞状态，待执行完毕后，其他的才能够执行 package Thread; public class TestJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 200; i++) { System.out.println(".
Java 多线程join()方法的作用和实现原理解析
csdn_aiyang的博客
08-22 4788
join()：等待该线程结束，才能执行其他线程。 通常用于在main()主线程内，等待其它线程完成再执行main()主线程。Join方法实现原理是通过wait方法， 当main线程调用Thread.join()时，main线程会获得线程对象的锁，调用该对象的wait()，直到该对象唤醒main线程 。这就意味着main 线程调用Thread.join时，必须能够拿到线程对象的锁。
详解Java线程中的join()方法
wzwjm123的博客
05-17 1万+
对于Java中的join()方法的描述，我们首先来看下源码当中的解释 从源码当中的描述，我们只能知道join方法的作用是让线程陷入等待。其中可以传递以毫秒为单位的等待时间参数，如果传递参数为0，则线程会一直等待。 其实对于join方法，网上有很多解释，大都是只说如何使用，并没有对join当中的实现进行分析。 因此，在此结合网上的各种说法，对线程中的join方法进行源码分析，同时也记录自己的学习过程。 首先先来了解join方法如何使用，以及它的作用。 为了更有对比性的展示，首先来个简单并正常使用（不使
Java多线程［2］：join() 方法
朱登凯的专栏
09-30 960
join()方法的使用场景假设我们在主线程中创建了一个线程，这个线程要执行很长时间，我希望这个线程执行完并结束以后，主线程再结束，也就是说，我希望主线程能够晚于子线程结束。因为我们不知道子线程要执行多久，所以，也不知道主线程要等待多久，所以，join()方法诞生了。
Java Thread.join()详解
热门推荐
android的博客
08-17 4万+
 一、使用方式。 join是Thread类的一个方法，启动线程后直接调用，例如： Thread t = new AThread(); t.start(); t.join(); 二、为什么要用join()方法 在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值