线程常用方法你了解吗（join、yield、interrupt）

已于 2024-04-08 10:10:00 修改
阅读量1.3k 收藏 16
点赞数 25
分类专栏： 【JUC源码】 文章标签： java 多线程 juc 并发
于 2024-03-30 10:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118323/article/details/137017464
版权

前言：

理解线程常用方法，有助于我们对多线程有更深入的理解，你都知道哪些线程常用的方法，各自又有什么作用？本文将对线程 join、yield、interrupt 方法进行详解。

常用方法：

  • sleep：线程休眠。
  • wait：线程等待。
  • notify：单个线程唤醒。
  • notifyAll：唤醒所有线程。
  • join：线程强占。
  • yield：线程让步。
  • interrupt：线程打断。

线程常用方法你了解吗（sleep、wait、notify、notifyAll）

join 方法：

线程强占（谁调用 join 方法，谁就强占 cpu 资源，直到调用者执行结束），就是调用该方法的线程强占 cpu 时间片，join 方法 jdk 源码注释中描述的 等待该线程死亡，该线程值指的就是调用 join 方法的线程，也就是如果调用了 join 方法，那么 join 方法后面的代码，要等调用线程执行完毕后才可以得到执行。

源码简单分析：

public final void join() throws InterruptedException {
        join(0);
 }
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;
            }
        }
    }
  //判断线程状态 如果线程活着 就返回true 否则返回 false
  public final native boolean isAlive();

分析：根据源码我们可以知道 join 方法底层还是调用的 wait 方法，同时 join 方法中有一个 isAlive 方法，判断调用者线程是否存活，当调用者线程结束后，返回 false，while 循环结束（被强占 cpu 时间片的线程可以恢复执行了），注意这里的 wait(0)，不是等待 0 秒，而是一直等待，直到调用 join 方法的线程执行结束，同时join 方法支持传入时间，这时候就会走另外一个分支，等待指定时间，join 方方法中的 wait 方法无需唤醒操作。

代码演示如下：

public class ThreadDemo extends Thread {


    public ThreadDemo() {
    }

    @Override
    public void run() {
        System.out.println("当前线程准备进入休眠,线程名称:" + Thread.currentThread().getName()+ ",当前时间:"+  System.currentTimeMillis() / 1000);
        try {
            //休眠 2 秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程休眠结束,线程名称:" + Thread.currentThread().getName()+ ",当前时间:"+  System.currentTimeMillis() / 1000);
    }


    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始运行,线程名称:" + Thread.currentThread().getName()+ ",当前时间:"+  System.currentTimeMillis() / 1000);
        ThreadDemo threadDemoOne = new ThreadDemo();
        threadDemoOne.start();
        //join 强占 cpu
        threadDemoOne.join();
        System.out.println("主线程结束运行,线程名称:" + Thread.currentThread().getName()+ ",当前时间:"+  System.currentTimeMillis() / 1000);
    }
}

没有使用 join 方法执行结果：

主线程开始运行,线程名称:main,当前时间:1711184107
主线程结束运行,线程名称:main,当前时间:1711184107
当前线程准备进入休眠,线程名称:Thread-0,当前时间:1711184107
当前线程休眠结束,线程名称:Thread-0,当前时间:1711184109

使用 join 方法执行结果：

主线程开始运行,线程名称:main,当前时间:1711184126
当前线程准备进入休眠,线程名称:Thread-0,当前时间:1711184126
当前线程休眠结束,线程名称:Thread-0,当前时间:1711184128
主线程结束运行,线程名称:main,当前时间:1711184128

使用 join 方法设置 join 时间的执行结果：

主线程开始运行,线程名称:main,当前时间:1711185453
当前线程准备进入休眠,线程名称:Thread-0,当前时间:1711185453
主线程结束运行,线程名称:main,当前时间:1711185454
当前线程休眠结束,线程名称:Thread-0,当前时间:1711185455

执行结果分析：注意观察执行结果中的时间（秒），根据执行结果可知，没有使用 join 时候，main 线程先执行结束，使用了 join，main 线程最后执行完，而设置了 join 时间的时候，我们发现时间到了，主线程就重新获得了 cpu 时间片，我们知道在很多情况下，都是通过主线程创建子线程的并启动子线程的，如果子线程中的业务需要比较长的时间，这时主线程往往会比子线程先结束，就会导致有时候主线程想获取子线程执行的业务结果，但是却获取不到，这个时候，就通过join方法来解决这个问题。

yield 方法：

线程让步，简单来说就是线程让出自己的 cpu 时间片，源码注释翻译为当前线程向调度程序申请让出对 cpu 处理器的使用，简单说就是主动放弃已经获取到的 cpu 时间片的执行权。

源码如下：

public static native void yield();

分析源码：

  • public static ：静态方法，是 Thread 类的方法，可以通过类名调用。
  • native ：yield 是一个 native 方法，简单理解就是操作系统的方法。
  • yield 方法没有异常抛出。
  • yield 方法结束后就转入就绪的状态。
  • yield 只会给优先级相同或者优先级更高的线程让步。

yield 方法效果测试：

场景设计：yield 方法既然是让出自己的 cpu 时间片，那如果做一个相同的操作，直接执行完和让出 cpu 时间片，小消耗的时间肯定不一样，按理论分析，不使用 yield 方法消耗的时间要小于使用 yield 方法消耗的时间，我们做如下测试。

测试代码：

public class ThreadDemo extends Thread {


    public ThreadDemo() {
    }

    @Override
    public void run() {
        long start = System.currentTimeMillis() ;
        System.out.println("当前线程准备进入计算,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis() );
        for (int a = 0; a < 1000000000; a++) {
            a = a + 1;
            //Thread.yield();
        }
        System.out.println("当前线程计算结束,线程名称:" + Thread.currentThread().getName() + ",消耗时间:" + (System.currentTimeMillis()  - start));
    }


    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始运行,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis() );
        ThreadDemo threadDemoOne = new ThreadDemo();
        threadDemoOne.start();
        System.out.println("主线程结束运行,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis() );
    }
}

没有使用 yield 方法测试结果：

主线程开始运行,线程名称:main,当前时间:1711187136105
主线程结束运行,线程名称:main,当前时间:1711187136106
当前线程准备进入计算,线程名称:Thread-0,当前时间:1711187136107
当前线程计算结束,线程名称:Thread-0,消耗时间:4

使用 yield 方法测试结果：

主线程开始运行,线程名称:main,当前时间:1711288301021
主线程结束运行,线程名称:main,当前时间:1711288301022
当前线程准备进入计算,线程名称:Thread-0,当前时间:1711288301022
当前线程计算结束,线程名称:Thread-0,消耗时间:37263

结果分析：
很明显使用 yield 方法，同样的逻辑处理，消耗的时间远大于使用了 yield 方法，证明 yield 方法生效，在实际的开发场景中，yield 方法的使用场景比较少。

interrupt 方法：

线程打断，打断调用者线程，但是 interrupt 方法和 stop 方法有本质区别，它并不会向 stop 方法一样直接中断一个线程的运行，调用 interrupt 方法的线程会继续运行下去，但是会设置一个中断标志 true，由调用者线程决定什么时候来来判执行线程中断，，，，，，，，，，，，，，，，，，。

使用 stop 方法中断线程会有什么问题？

使用 stop 方法虽然可以强行终止正在运行的线程，但使用 stop 方法是有隐患的，stop 方法杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁，这个后果就很严重了。

打断分类：

  • 打断正在运行的线程，interrupt 方法去打断正在运行线程时，被打断的线程会继续运行，但是该线程的打断标记会更新为true，可以根据打断标记来作为判断条件使得线程停止。
  • 打断处于阻塞状态的线程，interrupt 方法打断阻塞状态的线程时，会抛出异常，然后重置状态为 false，因此线程虽然被打断，但是打断标记依然为false。

打断正在运行的线程：

public class ThreadDemo extends Thread {


    public ThreadDemo() {
    }

    @Override
    public void run() {
        System.out.println("执行业务,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis() / 1000);
        System.out.println("循环开始前打断标记为:" + Thread.currentThread().isInterrupted());
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("线程死循环了,线程中断标记:" + Thread.currentThread().isInterrupted());
        }
        System.out.println("循环结束后打断标记为:" + Thread.currentThread().isInterrupted());

    }


    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始运行,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis());
        ThreadDemo threadDemoOne = new ThreadDemo();
        threadDemoOne.start();
        //睡眠1毫秒 让线程跑一会儿
        Thread.sleep(1);
        //打断线程
        threadDemoOne.interrupt();
        System.out.println("主线程结束运行,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis());
    }
}

演示结果：

主线程开始运行,线程名称:main,当前时间:1711291731296
执行业务,线程名称:Thread-0,当前时间:1711291731
循环开始前打断标记为:false
线程死循环了,线程中断标记:false
线程死循环了,线程中断标记:false
。。。。。。
线程死循环了,线程中断标记:false
线程死循环了,线程中断标记:false
主线程结束运行,线程名称:main,当前时间:1711291731299
循环结束后打断标记为:true

结果分析：可以看到，我们启动子线程后，让主线程睡眠了 1 毫秒再执行子线程打断操作，结果也是如我们所料，还是现在执行了部分循环，后续自动停止了。

打断处于阻塞状态的线程：

public class ThreadDemo extends Thread {


    public ThreadDemo() {
    }

    @Override
    public void run() {
        System.out.println("执行业务,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis() / 1000);
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("线程死循环了,线程中断标记:" + Thread.currentThread().isInterrupted());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("循环结束后打断标记为:" + Thread.currentThread().isInterrupted());

    }


    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始运行,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis());
        ThreadDemo threadDemoOne = new ThreadDemo();
        threadDemoOne.start();
        //睡眠1毫秒 让线程跑一会儿
        Thread.sleep(1);
        //打断线程
        threadDemoOne.interrupt();
        System.out.println("主线程结束运行,线程名称:" + Thread.currentThread().getName() + ",当前时间:" + System.currentTimeMillis());
    }
}

演示结果：

在这里插入图片描述

结果分析：

  • 这里要使用 debugger 调试，才可以打印出为 true 的结果。
  • 可以很明显的看到，异常抛出之后，就无法获取到打断标志为 ture 的结果了，证实了抛出异常重置打断标注状态为 false。

终止线程的方式：

  • 线程运行完毕正常结束。
  • 共享变量结束线程，有些情况，线程需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程，我们使用某个变量，通过对变量值的判断来控制线程结束。
  • 上面讲到的使用 interrupt 方法结束线程。
  • 使用 stop 方法结束线程，不推荐使用，stop 方法结束线程有很大的风险，比如线程持有的锁没有被释放，被 stop 后会导致死锁发生。

如有错误的地方欢迎指出纠正。

码农爱java
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
yield方法释放锁吗_多线程-线程常见方法详解
weixin_30646537的博客
01-13 3097
sleep方法:让线程睡眠sleep()方法是Thread类的静态方法，调用线程会暂时让出指定时间的CPU执行权，把CPU执行权让给其他线程，等到睡眠时间一到，该函数就会正常返回，此线程会自动苏醒。苏醒后，线程就处于就绪状态，然后参与CPU的调度，获取到CPU资源后就可以继续运行了。注意:sleep方法会让出CPU资源,但是不会释放锁.如果在睡眠期间其他线程调用了该线程的interrupt()方法...
JavaScript使用yield模拟多线程的方法
10-24
主要介绍了JavaScript使用yield模拟多线程的方法,实例分析了javascript多线程的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
java.lang.Thread类详解，yield方法，join方法，interrupt方法，interrupted方法，destroy方法
qq_43842093的博客
08-01 1091
一、前言 位于java.lang包下的Thread类是非常重要的线程类，它实现了Runnable接口，今天我们来学习一下Thread类，在学习Thread类之前，先介绍与线程相关知识：线程的几种状态、上下文切换，然后接着介绍Thread类中的方法的具体使用。 二、线程的状态 在正式学习Thread类中的具体方法之前，我们先来了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。 线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnab
Java线程相关，join，interrupt，wait等方法总结
Rayman的博客
02-10 412
线程的启动 线程的启动方式有以下三种： 1、X extends Thread;，然后X.run 2、X implements Runnable；然后交给Thread运行 3、X implements Callable；然后交给Thread运行 先看代码： public class NewThread { /*扩展自Thread类*/ private static class ...
线程常用方法你了解吗（sleep、wait、notify、notifyAll）
weixin_42118323的博客
03-29 883
void wait(long timeout, int nanos)： 调用者线程等待指定时间，直到其他线程为此线程调用 notify 方法或 notifyAll 方法，或者其他线程中断当前线程，方法提供了一个 nanos 值更好的控制等待的时间，但是根据源码来看，其实并没有真正使用这个值。让线程休眠指定的时间，时间到了线程将会恢复执行，需要注意的是 sleep 方法会让线程让出 cpu 时间片，但是不是释放持有的锁，如果持有锁对象的线程调用了 sleep 方法，那其他线程一样得不到这个锁对象。
【多线程系列】线程的状态与常用方法详解
王华春_Jason
06-25 883
一、线程的状态 1、线程状态，线程可以处于以下状态之一： NEW 尚未启动的线程处于此状态。 RUNNABLE 在 Java 虚拟机中执行的线程处于这种状态。 BLOCKED 被阻塞等待监视器锁的线程处于这种状态。 WAITING 无限期等待另一个线程执行特定操作的线程处于此状态。 TIMED_WAITING 等待另一个线程执行操作达指定等待时间的线程处于此状态。 TERMINATED 已退出的线程处于此状态。 一个线程在给定的时间点只能处于一种状态。 这些状态是不反映任何操作系统线程状态
Java多线程系列--join()和yield()和interrupt()理解
张姐姐聊编程
08-16 3244
join()和yield()和interrupt()理解
理解多线程join、sleep、yield、interrupt方法
baidu_28149499的博客
02-05 386
一、join方法 在项目中我...
Java多线程学习（三）Thread基本函数详解（sleep、yield、join、interrupt、守护线程、优先级）
chen_changtui的博客
03-05 712
sleep、yield、join sleep： api： sleep(long millis) //参数为毫秒 sleep(long millis,int nanoseconds) //第一参数为毫秒，第二个参数为纳秒 注意点：sleep就是让线程睡眠，交出CPU，但是值得注意的是它不会释放锁 优先级 高优先级被优先执行的记录更大 最低优先级 1：Thread.MIN_PRIORITY ...
并发编程-多线程常用方法interrupt、isInterrupted、interrupted、yield、Join
weixin_45628438的博客
07-26 167
Thread类中常用方法使用与源码解析 - getName（） 获取线程名 private volatile String name; /······/ public final String getName() { return name; } 获取一个线程的名称，是被volatile 修饰的线程安全的属性； - setName （String）修改线程名 线程名称可以在线程被初始化得时候赋值，也可以初始化完成后使用set方法进行赋值 public final s
Java线程中yield与join方法的区别
12-22
之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 　Java线程调度...
Java线程中yield与join方法的区别Java开发J
11-25
Java线程中yield与join方法的区别Java开发Java经验技巧共6页.pdf.zip
线程中sleep、join、yield、wait的区别
12-22
给出一段准备代码，相信各位一看就懂，不懂，你不懂那我不能揍你呀。 ThreadTest： package hsy.cool.threadJY; /** * 项目准备 * @author 爱猫狗的小郝_河南济源追梦孩 */ public class ThreadTest extends ...
java学习和项目总结
2301_79390585的博客
05-24 698
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1440
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
JVM学习-执行引擎
丢爸
05-21 1146
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
数据访问与Spring Data JPA
无远弗届
05-25 528
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
operator ＜=＞ (spaceship operator)
最新发布
janeqi1987的专栏
05-28 588
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
java多线程的常用方法
04-03
4. join()方法：等待线程执行结束，然后再继续执行当前线程。 5. interrupt()方法：中断线程的执行。 6. isAlive()方法：判断线程是否还在执行。 7. yield()方法：让出线程的执行权，让其他线程先执行。 8. set...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值