多线程之方法join的使用

最新推荐文章于 2024-06-07 10:41:24 发布
最新推荐文章于 2024-06-07 10:41:24 发布
阅读量349 收藏
点赞数 1
文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27581753/article/details/106273350
版权

在很多情况下，主线程穿件并启动子线程，如果子线程中药进行大量的耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join方法了。方法join的作用是等待线程对象销毁。
先来看一下一个示例代码：

package JoinTest;

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

package JoinTest;

/**
 * @Author LiBinquan
 */
public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("我想当threadTest对象执行完毕后我再执行");
        System.out.println("但上面代码中的sleep 中的值应该写多少呢");
        System.out.println("答案是：不能确定");
    }
}

输出：
在这里插入图片描述

1.使用join方法解决

修改Test.java

package JoinTest;

/**
 * @Author LiBinquan
 */
public class Test {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            myThread.join();
            System.out.println("我想当threadTest对象执行完毕后我再执行");
            System.out.println("但上面代码中的sleep 中的值应该写多少呢");
            System.out.println("答案是：不能确定");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

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

2.方法join与异常

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

package JoinTest;

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

线程b：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadB extends Thread{
    @Override
    public void run() {
        try{
            ThreadA a = new ThreadA();
            a.start();
            a.join();
            System.out.println("线程B在run end 处打印");
        }catch (InterruptedException e){
            System.out.println("线程B在异常处打印");
            e.printStackTrace();
        }

    }
}

线程c：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadC extends Thread{
    private ThreadB threadB;
    public ThreadC(ThreadB threadB){
        this.threadB = threadB;
    }

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

运行类：

package JoinTest;

/**
 * @Author LiBinquan
 */
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 (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
由输出说明，方法join和interrupt方法如果遇到，则会出现异常，但是进程的按钮还是呈”红色“，原因是线程ThreadA并未出现异常时正常执行的状态。

3.方法join(long)的使用

方法join(long)中的参数是设定等待的时间。
示例代码：
Mythread类：

package JoinTest;

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

运行类：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class Test {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            myThread.join(2000);
            System.out.println("end time = "+System.currentTimeMillis());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
其实这边将myThread.join(2000)改为myThread.sleep（2000）运行结果还是等待了2秒。有兴趣可以自己修改运行一下。

4.方法join(long)与sleep(long)的区别

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

 /**
     * Waits at most {@code millis} milliseconds for this thread to
     * die. A timeout of {@code 0} means to wait forever.
     *
     * <p> This implementation uses a loop of {@code this.wait} calls
     * conditioned on {@code this.isAlive}. As a thread terminates the
     * {@code this.notifyAll} method is invoked. It is recommended that
     * applications not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     *
     * @param  millis
     *         the time to wait in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    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)方法却不释放锁。在下面的示例中将测试Thread.sleep(long)方法具有不释放锁的特点。
示例代码如下：
线程A

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadA extends Thread{
    private ThreadB threadB ;
    public ThreadA(ThreadB threadB){
        super();
        this.threadB = threadB;
    }
    @Override
    public void run() {
        try{
            synchronized (threadB){
                threadB.start();
                Thread.sleep(6000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程b

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadB extends Thread{
    @Override
    public void run() {
        try{
            System.out.println("  b run begin time = "+System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("  b run   end time = "+System.currentTimeMillis());
        }catch (InterruptedException e){
            System.out.println("线程B在异常处打印");
            e.printStackTrace();
        }
    }
    synchronized public void bService(){
        System.out.println("打印了bService time = "+System.currentTimeMillis());
    }
}

线程c

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadC extends Thread{
    private ThreadB threadB;
    public ThreadC(ThreadB threadB){
        this.threadB = threadB;
    }

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

运行类：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            ThreadB b = new ThreadB();
            ThreadA a = new ThreadA(b);
            a.start();
            Thread.sleep(1000);
            ThreadC c = new ThreadC(b);
            c.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
由输出可得，由于线程ThreadA使用Thread.sleep(long)方法一直持有ThreadB对象的锁，时间达到6秒，所以线程ThreadC只有在ThreadA时间达到6秒后释放ThreadB的锁时，才可以调用ThreadB中的同步方法synchronized public void bService().
上面测试证明Thread.sleep(long)方法不释放锁。
接下来测试join()方法释放锁。
修改线程A

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadA extends Thread{
    private ThreadB threadB ;
    public ThreadA(ThreadB threadB){
        super();
        this.threadB = threadB;
    }
    @Override
    public void run() {
        try{
            synchronized (threadB){
                threadB.start();
                threadB.join();
                for (int i = 0; i < Integer.MAX_VALUE; i++) {
                    String str = new String();
                    Math.random();
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
由于线程ThreadA释放了ThreadB的锁，所以线程ThreadC可以调用ThreadB中的同步方法synchronized public void bService();

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

这边说明一下使用join会遇到的陷阱。
线程A：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadA extends Thread{
    private ThreadB threadB ;
    public ThreadA(ThreadB threadB){
        super();
        this.threadB = threadB;
    }
    @Override
    public void run() {
        try{
            synchronized (threadB){
                System.out.println("begin A ThreadName = "+Thread.currentThread().getName()+"  "+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("  end A ThreadName = "+Thread.currentThread().getName()+"  "+System.currentTimeMillis());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程B

package JoinTest;

/**
 * @Author LiBinquan
 */
public class ThreadB extends Thread{
    @Override
    synchronized public void run() {
        try{
                System.out.println("begin B ThreadName = "+Thread.currentThread().getName()+"  "+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("  end B ThreadName = "+Thread.currentThread().getName()+"  "+System.currentTimeMillis());

        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    synchronized public void bService(){
        System.out.println("打印了bService time = "+System.currentTimeMillis());
    }
}

运行类：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            ThreadB b = new ThreadB();
            ThreadA a = new ThreadA(b);
            a.start();
            b.start();
            b.join(2000);
            System.out.println("       main end "+System.currentTimeMillis());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
在这里插入图片描述
这个就是陷阱，就是join方法后面的代码提前运行了。

6.方法join()后面的代码提前运行：释放意外

示例代码：
修改run运行类：

package JoinTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
            ThreadB b = new ThreadB();
            ThreadA a = new ThreadA(b);
            a.start();
            b.start();
            System.out.println("       main end "+System.currentTimeMillis());
    }
}

输出：
在这里插入图片描述
我们可以多次运行，然后可以发现：main end 往往都会第一个打印。所以可以完全确定得出:方法join（2000）大部分是先运行的，也就是先抢到ThreadB的锁，然后快速进行释放。

道墟
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 多线程join方法的使用
抛弃幻想，准备斗争
03-23 675
在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束，这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。 方法join():等待线程对象销毁。 作用：使所属的线程对象x正常执行run()方法中的任务，而使线程z进行无限制的阻塞， 等待线程x销毁后再继续执行线程z后面...
JAVA多线程之方法 JOIN详解及实例代码
08-31
Java中的`join()`方法是多线程编程中的一个重要特性，用于控制线程间的协作和同步。在Java中，多线程允许程序同时执行多个任务，但有时我们需要确保某些线程按照特定顺序完成，或者主线程需要等待其他线程执行完毕后...
理解多线程中的join方法
fngy123的专栏
10-08 6614
join方法用得不多，当A线程执行到了B线程的join()方法时，A就会等待，等B线程都运行完，A线程才会执行。使用join()方法时，会产生异常。 用一个小程序说明join方法的使用技巧： class Demo implements Runnable {  public void run()  {   for(int x=1; x   {        System.ou
Java 中的 Thread.join() 方法详解
最新发布
csdn_life18的博客
06-07 1382
在多线程编程中，线程的管理和协调是一个重要课题。Java 提供了多种机制来实现线程之间的协调，其中之一就是方法。join()方法允许一个线程等待另一个线程完成，这在很多场景中是非常有用的。例如，当我们需要确保某个任务在继续之前必须先完成另一个任务时，join()方法就是一个很好的选择。
多线程 join方法的使用
脚踏大地走不停歇
08-08 365
在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后在结束，比如子线程处理一个数据，主线程要取的这个数据中的值，就要用到join()方法。join()方法的作用是等待线程对象销毁。 join()与 join(long) 方法 都有释放锁的特点。 1.join() 方法 线程代码 public class...
多线程中join方法的使用
weixin_45333084的博客
07-22 182
加入了join() package niukewang; public class MyThread extends Thread { public MyThread(String name) { super(name); } @Override public void run() { for (int i = 0; i <= 20; i++) { System.out.println(this.getNam
多线程学习----join()的用法
凌大大的博客
04-09 745
join的用法一   join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行。   首先来看个例子： /** * @author QingHe * Creation on 2005-12-19 */ public class ThreadTest implements Runnable { p...
java多线程编程之join方法的使用示例
09-04
Java多线程编程中的`join()`方法是线程同步的一种重要机制，它的主要作用是确保当前线程等待另一个指定线程执行完毕后再继续执行。在并发编程中，当我们需要依赖其他线程的结果或者顺序执行一系列任务时，`join()`...
Java多线程中关于join方法的使用实例解析
08-31
本文将深入探讨`join()`方法的使用及其在Java多线程中的作用。 `join()`方法是`java.lang.Thread`类的一个成员方法，它的主要功能是让当前线程等待调用`join()`方法的线程执行完毕后再继续执行。这意味着，当主线程...
浅谈java线程join方法使用方法
08-25
浅谈Java线程join方法使用方法 Java中的线程join方法是一种实现线程同步的方式，可以将原本并行执行的多线程方法变成串行执行的。在Java中，线程join方法的作用是使当前线程等待另一个线程的结束，然后再继续执行...
Java多线程join方法实例代码
08-28
Java多线程join方法实例代码 Java多线程join方法是一种非常重要的技术，在Java并发编程中，线程的join方法可以使得一个线程等待另一个线程的执行完毕，然后继续执行。这种机制可以确保线程的正确执行顺序，避免了...
多线程中join( )方法的使用
花&败
02-18 278
先写一个子线程 public class MyThread extends Thread{ public MyThread(String name){ super(name); } @Override public void run(){ for(int i=0;i<=20;i++){ System.out.println(this.getName() + ":" + i); } }
Java多线程中join的用法
ghl_kevin的博客
05-21 658
在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时计算，主线程会比子线程提前结束，如果主线程需要用到子线程返回的结果，就要用到join（）方法了，这样就将异步的变为同步的了。 比如下面这个例子，如果不用join（），我们将无法控制运行流程 子线程随机休眠时间 public class ThreadA extends Thread{ public vo
多线程中join的作用
蓝天it（让亿万孩子在蓝天下共享优质教育）
11-03 227
多线程中join的作用
多线程中join的用法
iteye_2933的博客
07-03 123
join(long millis)在jdk里是这样定义的等待该线程终止的时间最长为 millis 毫秒。超时为 0 意味着要一直等下去。直接看代码 public class JoinTest implements Runnable {  private static int a = 0; public void run() {  while(a&lt;10000000){   a++;  }...
Java多线程 -join用法
weixin_34273481的博客
06-28 97
  阿里面试官问我这个问题，我仔细总结了一下：   参考：sleep、yield、wait、join的区别(阿里面试)   1. join()介绍 join() 定义在Thread.java中。join() 的作用：让“主线程”等待“子线程”结束之后才能继续运行。这句话可能有点晦涩，我们还是通过例子去理解：   // 主线程 public class Father exten...
Java多线程专题-多线程join方法的作用
一名coder
06-02 342
Join方法概述 join作用是让其他线程变为等待。 t1.join(); // 让其他线程变为等待，直到当前t1线程执行完毕，才释放。 thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 class JoinThread implements Runn...
join() 在多线程中的使用
m0_62943934的博客
11-07 2644
在很多情况下，主线程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束，这时如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，这个时候就要用到 join() 方法了。方法 join() 的作用是等待线程对象销毁。
java多线程join的作用与用法
wjxbj的博客
04-02 225
        对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever。字面意...
Java多线程深度解析：join方法探秘
本文将深入探讨Java多线程中的关键知识点，特别关注`join()`方法的使用和理解。 首先，多线程允许程序同时执行多个任务，提高系统效率。在Java中，可以通过实现`Runnable`接口或继承`Thread`类来创建线程。然而，多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值