线程间通信-方法join的使用

最新推荐文章于 2021-02-12 09:34:09 发布
最新推荐文章于 2021-02-12 09:34:09 发布
阅读量687 收藏 1
点赞数 1
分类专栏： 多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/facekbook/article/details/52345732
版权

　　在多数情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时计算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完了再结束。比如子线程处理一个数据，主线程要取到这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。

学习join方法前的铺垫：

创建如下代码：

public class MyThread extends Thread{
    @Override
    public void run() {
        int sencondValue = (int)(Math.random()*1000);
        System.out.println(sencondValue);
        try {
            Thread.sleep(sencondValue);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        //Thread.sleep(?);
        System.out.println("当myThread对象执行完毕后再执行");
        System.out.println("但上面代码的sleep的值写多少");
        System.out.println("答案是不确定");
    }
}

程序运行结果如下：
这里写图片描述

用join()方法来解决：

方法join可以解决这个问题。创建如下代码：

public class MyThread extends Thread{
    @Override
    public void run() {
        int sencondValue = (int)(Math.random()*1000);
        System.out.println(sencondValue);
        try {
            Thread.sleep(sencondValue);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.join();
        System.out.println("当对象myThread执行完毕后再执行");
    }
}

执行结果如下：
这里写图片描述
　　方法join的作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期阻塞，等待线程x销毁后再继续执行线程z后面的代码。
方法join具有使线程排队运行的作用，有些类似同步的效果。join与synchronized的区别是：join内部是使用wait()方法进行等待的，而synchronized关键字是使用的是“对象监视器”原理做为同步。

方法join与异常：

在join过程中，如果当前线程对象被中断，则当前线程出现异常。创建如下代码：

public class ThreadA extends Thread{
    @Override
    public void run() {
        for(int i=0;i<Integer.MAX_VALUE;i++){
            String newString = new String();
            Math.random();
        }
    }
}

public class ThreadB extends Thread {
    @Override
    public void run() {
        try {
            ThreadA ta = new ThreadA();
            ta.start();
            ta.join();
            System.out.println("线程B在runend处打印了");
        } catch (InterruptedException e) {
            System.out.println("线程B在catch处打印了");

            e.printStackTrace();
        }
    }
}

public class ThreadC extends Thread{
    private ThreadB threadb;
    public ThreadC(ThreadB threadb){
        this.threadb = threadb;
    }

    @Override
    public void run() {
        threadb.interrupt();
    }
}

public class Run {
    public static void main(String[] args) {
        try{
            ThreadB b = new ThreadB();
            b.start();
            Thread.sleep(500);
            ThreadC c = new ThreadC(b);
            c.start();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

执行结果如下：
这里写图片描述
说明方法join()与interrupt()方法如果彼此相遇，则会出现异常。但进程按钮还是呈红色状态，原因是线程ThreadA还在继续运行，线程ThreadA并未出现异常，是正常的状态。

方法join(long)的使用：

方法join(long)中的参数是设定等待的时间。创建如下代码：

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("begin Time="+System.currentTimeMillis());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.join(2000);
        System.out.println("  end Time="+System.currentTimeMillis());
    }
}

执行结果如下：
这里写图片描述
运行结果等待了2秒。
但将main方法中的代码改为使用sleep(2000)方法时，运行的效果还是等待了2秒。如下所示：

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        // myThread.join(2000);
        Thread.sleep(2000);
        System.out.println("  end Time=" + System.currentTimeMillis());
    }
}

这里写图片描述

　　那使用sleep(2000)和使用join(2000)有什么区别，从上面的例子运行效果是看不出区别的，其实主要区别还是来自于这2个方法对同步的处理上。

方法join(long)和sleep(long)的区别：

方法join(long)的功能在内部是使用wait(long)方法来实现的，所有join(long)方法具有释放锁的特点，方法join(long)的源码如下：

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

从源码中可以了解到，当执行wait(long)方法后，当前线程的锁被释放，那么其他线程就可以调用此线程中的同步方法了。
而Thread.sleep(long)方法却不释放锁。创建如下代码：

public class ThreadB extends Thread{
    @Override
    public void run() {
        System.out.println(" b run begin timer="+System.currentTimeMillis());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(" b run end   timer="+System.currentTimeMillis());
    }

    synchronized public void bService(){
        System.out.println("打印了 bService timer="+System.currentTimeMillis());
    }
}

public class ThreadA extends Thread{
    private ThreadB threadB;

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

    @Override
    public void run() {
        synchronized(threadB){
            threadB.start();
            try {
                Thread.sleep(6000);
                //Thread.sleep()方法不释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadC extends Thread{
    private ThreadB threadB;

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

    @Override
    public void run() {
        threadB.bService();
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        ThreadB threadB = new ThreadB();
        ThreadA threadA = new ThreadA(threadB);
        threadA.start();
        Thread.sleep(2000);
        ThreadC threadC = new ThreadC(threadB);
        threadC.start();
    }
}

执行结果如下：
这里写图片描述
由于线程threadA使用了Thread.sleep(long)方法一直持有ThreadB的对象锁，时间达到6秒，所以线程ThreadC只有在ThreadA时间达到6秒后释放ThreadB的锁时，才可以调用ThreadB中的同步方法synchronized public void bService()。
此实验也说明Thread.sleep(long)方法不释放锁。
修改ThreadA类如下：

public class ThreadA extends Thread{
    private ThreadB threadB;

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

    @Override
    public void run() {
        synchronized(threadB){
            threadB.start();
            try {
                //Thread.sleep(6000);
                //Thread.sleep()方法不释放锁
                threadB.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果如下：
这里写图片描述
由于线程ThreadA释放了ThreadB的锁，所以线程ThreadC可以调用线程ThreadB的同步方法synchronized public void bService()。
这个实验也说明join(long)方法具有释放锁的功能。

方法join()后面的代码提前运行：出现意外

如果不注意使用join(long)方法的使用，就会掉进“陷进”里。创建如下代码：

public class ThreadA extends Thread{
    private ThreadB threadB;
    public ThreadA(ThreadB threadB){
        this.threadB = threadB;
    }

    @Override
    public void run() {
        synchronized(threadB){
            System.out.println("begin A ThreadName="+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end   A ThreadName="+Thread.currentThread().getName()+" "+System.currentTimeMillis());
        }
    }
}

public class ThreadB extends Thread{

    @Override
    synchronized public void run() {
        System.out.println("begin B ThreadName="+Thread.currentThread().getName()+" "+System.currentTimeMillis());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end   B ThreadName="+Thread.currentThread().getName()+" "+System.currentTimeMillis());
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        ThreadB threadB = new ThreadB();
        ThreadA threadA = new ThreadA(threadB);
        threadA.start();
        threadB.start();
        threadB.join(2000);
        System.out.println("main end "+System.currentTimeMillis());
    }
}

执行结果如下：
这里写图片描述
或
这里写图片描述
为什么会出现不同的结果呢？
为了查看join方法在Run类中执行的时机，创建如下代码：

public class RunFirst {
    public static void main(String[] args) {
        ThreadB threadB = new ThreadB();
        ThreadA threadA = new ThreadA(threadB);
        threadA.start();
        threadB.start();
        System.out.println("                   main end "+System.currentTimeMillis());
    }
}

执行结果如下：
第一次运行结果：
这里写图片描述
第二次运行结果：
这里写图片描述
通过多次运行RunFirst类后，可以发现一个规律：main end往往都是第一个打印的。所以可以完全确定地得出一个结论：方法join(2000)大部分是先执行的，也就是先抢到ThreadB的锁，然后快速释放。
而执行Run类就会出现一些不同的结果。先看下面：
这里写图片描述
1、b.join(2000)方法先抢到B的锁，然后将B锁进行释放。
2、ThreadA抢到锁，打印ThreadA begin并且Thread.sleep(5000)。
3、ThreadA打印ThreadA end。
4、这时join(2000)和ThreadB争抢锁，而join(2000)再次获得锁，发现时间已过，释放锁后打印main end。
5、ThreadB获得锁，并且Thread.sleep(5000)。
6、5秒后打印ThreadB end。
再看下图
这里写图片描述
1、 join(2000)方法抢到B锁，然后马上释放。
2、 ThreadB抢到锁，打印ThreadB begin并且Thread.sleep(5000).
3、 5秒后打印ThreadB end，释放锁。
4、 这时join(2000)和ThreadA争抢锁，ThreadA获得锁，打印ThreadA begin并且Thread.sleep(5000)。
5、 5秒后打印ThreadA end。
6、 最后打印main end。

在路上的JavaCoder-尹骑
关注
专栏目录
51.线程间的通信-join方法- join方法的使用.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
52.线程间的通信-join方法-join方法与异常.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
Java多线程——线程间通信之join()方法
laoXingyao的博客
06-01 329
1.  join()方法：当前线程 等待 线程对象 销毁。比如说：   j.join();    //就是当前线程 等待 线程对象（j） 销毁。package threadCommunication; public class JoinTest extends Thread { @Override public void run() { try { ...
【多线程 七】 线程间通信之join()
李光 未来科技
01-06 290
前言 前面我们全面介绍了多线程间是如何通信的： 地址链接，接下来我们详细的介绍join方法，它有什么作用解决了什么问题。 1、引入 在多线程的环境中，如果要想实现这样一个效果：子线程的执行过程中比较耗费时间，但是我想 主线程在子线程执行完之后再执行，这时候有一个方法它可以解决此问题，那就是join方法 2、代码展示 2.1 创建一个线程MyThread public class MyThread extends Thread { @Override public void run() {
java-Thread.join进行线程通信
aoshanshu6185的博客
09-03 98
使用场景 线程A执行到一半，需要一个数据，这个数据需要线程B去执行修改，只有B修改完成之后，A才能继续操作 线程A的run方法里面，调用线程B的join方法，这个时候，线程A会等待线程B运行完成之后，再接着运行 代码： 结果： 源码 　　 完成！！！ 转载于:https://www.cnblogs.com/woxbwo/p/11450782.html...
JAVA多线程-线程间通信(四)-join的使用
绝版灬小伙的博客
02-21 396
方法join的使用         在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()这个方法了。方法join()的作用是等待线程对象销毁。 demo案例： package org.jksoft.thread.join
C#--使用Timer类和Join方法管理线程
weixin_34289744的博客
05-11 85
Timer类允许将"fire-and-forget"线程添加到用户程序。在实例化Timer对象时，需要指定以下4个参数 callback　　提供Timer将调用方法的TimerCallback委托 state　　应该传递给TimerCallback方法的对象。这个参数可为null dueTime　　Timer首次激发之前延迟的毫秒数 Period　　Timer调用之间的毫秒数。 ...
53.线程间的通信-join方法-ThreadLocal类.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
52.线程间的通信-join方法- join(long)与sleep(long)的区别.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
L17-线程间通信-讲义.pdf
12-23
线程间通信是多线程编程中的重要概念，主要用于解决多个并发执行的线程如何协作完成任务的问题。在Android系统中，线程间通信尤为重要，因为它涉及到UI更新和后台任务的执行。本讲义主要探讨了线程间通信的本质、...
JAVA多线程顺序执行（使用join，lock,condition，信号量）原理和java源代码
weixin_33813128的博客
09-25 138
2019独角兽企业重金招聘Python工程师标准>>> ...
请说出你所知道的线程同步的方法。_你知道怎么实现多线程同步问题吗？join不算还知道吗...
weixin_34597791的博客
01-05 112
多线程线程：类似执行一个命令，多线程：并发执行多条命令。多线程的优点： 1.充分利用cpu的性能。 2.提高系统性能。 3.同一时刻处理可以处理不同的命令线程同步即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，为什么需要它呢？1.多线程会出现线程安全问题，线程同步可以有效的保证线程安全。 2.当主线程依赖两个子线程结果的时候，需要线程同步如何实现线程同...
python定时任务_Python3实现定时任务的四种方式
weixin_39643255的博客
11-20 418
最近做一个小程序开发任务，主要负责后台部分开发；根据项目需求，需要实现三个定时任务：1>定时更新微信token，需要2小时更新一次；2>商品定时上线；3>定时检测后台服务是否存活；使用Python去实现这三个任务，这里需要使用定时相关知识点；Python实现定点与定时任务方式比较多，找到下面四中实现方式，每个方式都有自己应用场景；下面来快速介绍Python中常用的定时任务实现方式：1>循环+sle...
python中的定时器，隔一段时间调用一个接口
mywpython的博客
10-30 5905
import threading import time def fun_timer():     print('Hello Timer!')     print(time.time()) while True:     print(time.time())     timer = threading.Timer(5, fun_timer)#等待5s钟调用一次fun_timer() 函数     ...
定时器 （TimerTask）
拔剑斩情丝
07-02 480
定时器 （TimerTask）： import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TestTimerTask { Timer timer; public TestTimerTa
Java_线程，Timer，线程组以及同步的方法
weixin_42929804的博客
09-19 216
进程和线程： 一个程序就是一个进程，可以打开资源管理器查看现在有多少个进程同时运行。 计算机是支持多进程的。 多线程的作用： 以游戏为例(需要一个线程来控制主角的移动，一个线程控制敌人的AI攻击行为)， 当需要多个任务同时运行时，就要使用多线程。 主线程： main方法处于一个默认的线程中，这个线程称为主线程，由系统默认创建出来(JVM创建启动)。 ...
Java计时器线程Timer/线程的联合//文件与文件系统
想带狗熊去吹风
06-08 196
计时器线程Timer 当某些操作需要周期性地执行时可以使用计时器,用户可以使用Timer类 使用Timer类的构造方法Timer(int a,Object b),其中a参数是指毫秒,b是指实现了ActionListener接口的类 当Timer类对象每隔a毫秒后自动"震铃"一次,并回调b对象中actionPerformed(ActionEvent e)方法,要想计时器只震铃一次可以让计时器调用setRepeats(boolean b)方法,参数b设置为false即可 另外计时器还可以调用setInitial
java任务_Java中的定时任务
weixin_28717611的博客
02-12 263
现代的应用程序早已不是以前的那些由简单的增删改查拼凑而成的程序了，高复杂性早已是标配，而任务的定时调度与执行也是对程序的基本要求了。很多业务需求的实现都离不开定时任务，例如，每月一号，移动将清空你上月未用完流量，重置套餐流量，以及备忘录提醒、闹钟等功能。Java 系统中主要有三种方式来实现定时任务：Timer和TimerTaskScheduledExecutorService三方框架 Quartz...
Java线程间通信：join、wait、notify与并发工具类解析
在需要线程间通信的地方，可以使用synchronized关键字保证线程安全。 7. **volatile关键字**: volatile确保了多线程环境下的可见性，即当一个线程修改了一个volatile变量时，其他线程可以立即看到修改。 8. **Lock...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值