JavaSE笔记7.8-多线程-停止线程

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

一. 停止线程的方法

在Java中有3种方法可以停止正在运行的线程
（1）使用stop( )方法强行停止线程，已被弃用
（2）在run( )方法的循环结构中使用退出标志，当run( )方法完成后线程停止
（3）使用interrupt( )方法中断线程

二. 在run( )方法的循环结构中使用退出标志

1. 使用方法

让run方法结束
因为开启多线程运行，运行代码通常都是循环结构，
所以只要控制住循环结构，就可以让run方法结束，也就是线程结束。

class StopThread implements Runnable{
    //标记flag用来控制循环的停止
    private boolean flag=true;
    public synchronized void run(){
        while (flag){
            System.out.println(Thread.currentThread().getName()+"...run");
        }
    }

    public void changeFlag(){
        flag=false;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)
    {
        StopThread st=new StopThread();
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        t1.start();
        t2.start();

		//主线程sleep，避免出现线程t1或t2未判断flag，flag已变为false
        try { Thread.sleep(10); } catch (Exception e){}
        
        int num=0;
        while(true)
        {
            if(num++==60)//1.自增（后），所以主线程会打印num=60
            {
                st.changeFlag();//2. flag标记置为假后，t1和t2都不再打印
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...run"+num);
        }
    }
}

运行结果是：
在这里插入图片描述

2. 特殊情况下存在的问题

当线程处于阻塞状态，就不会读取到标记，那么线程就不会结束

class StopThread implements Runnable{
    //标记flag用来控制循环的停止
    private boolean flag=true;
    public synchronized void run(){
        while (flag){
            try{
                //线程t1或t2进来，wait(),被冻结
                wait();
            }
            catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"...Exception");
            }
            System.out.println(Thread.currentThread().getName()+"...run");
        }
    }

    public void changeFlag(){
        flag=false;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)  {
        StopThread st=new StopThread();
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        t1.start();
        t2.start();

        //主线程sleep，避免出现线程t1或t2未判断flag，flag已变为false
        try { Thread.sleep(10); } catch (Exception e){}

        int num=0;
        while(true)
        {
            if(num++==60)//1.自增（后），所以主线程会打印num=60
            {
                st.changeFlag();//2. flag标记置为假后，t1和t2都不再打印
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...run"+num);
        }
    }
}

运行结果是：线程不能结束
在这里插入图片描述

3. 用interrupt( )解决特殊情况下的问题

在这里插入图片描述
用interrupt( )方法清除线程的阻塞状态

class StopThread implements Runnable{
    //标记flag用来控制循环的停止
    private boolean flag=true;
    public synchronized void run(){
        while (flag){
            try{
                //线程t1或t2进来，wait(),被冻结
                wait();
            }
            catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"...Exception");
            }
            System.out.println(Thread.currentThread().getName()+"...run");
        }
    }

    public void changeFlag(){
        flag=false;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)  {
        StopThread st=new StopThread();
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        t1.start();
        t2.start();

        //主线程sleep，避免出现线程t1或t2未判断flag，flag已变为false
        try { Thread.sleep(10); } catch (Exception e){}

        int num=0;
        while(true)
        {
            if(num++==60)//1.自增（后），所以主线程会打印num=60
            {
                //st.changeFlag();//2. flag标记置为假后，t1和t2都不再打印
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...run"+num);
        }
    }
}

运行结果是：
线程t1和t2被强制唤醒，分别处理异常后，打印了一次；然而flag仍为真，线程t1和t2再次被wait()，线程无法结束
在这里插入图片描述

class StopThread implements Runnable{
    //标记flag用来控制循环的停止
    private boolean flag=true;
    public synchronized void run(){
        while (flag){
            try{
                //线程t1或t2进来，wait(),被冻结
                wait();
            }
            catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"...Exception");
                //当interrupt处理后，线程被强制唤醒，异常被处理，flag就改为false来结束线程
                flag=false;
            }
            System.out.println(Thread.currentThread().getName()+"...run");
        }
    }

    public void changeFlag(){
        flag=false;
    }
}

class StopThreadDemo
{
    public static void main(String[] args)  {
        StopThread st=new StopThread();
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        t1.start();
        t2.start();

        //主线程sleep，避免出现线程t1或t2未判断flag，flag已变为false
        try { Thread.sleep(10); } catch (Exception e){}

        int num=0;
        while(true)
        {
            if(num++==60)//1.自增（后），所以主线程会打印num=60
            {
                //st.changeFlag();//2. flag标记置为假后，t1和t2都不再打印
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...run"+num);
        }
    }
}

运行结果是：
线程t1和t2被强制唤醒，分别处理异常后，打印了一次，flag被改为假，线程结束。
在这里插入图片描述

4. 总结
  • 特殊情况： 当线程处于阻塞状态，就不会读取到标记，那么线程就不会结束。
  • 当没有指定的方式让阻塞的线程恢复到运行状态时，这时就需要对阻塞状态进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。
  • Thread类中提供了该方法interrupt()

三. 使用interrupt( )方法中断线程

1. 所涉及的方法

定义在Thread类中
在这里插入图片描述

  • interrupt( )：作用是中断此线程（指调用该方法的线程），但实际上只是给线程设置一个中断状态，线程仍会继续运行。
  • interrupted( )：作用是测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态。
  • isInterrupted( )：作用是测试此线程（指调用该方法的线程）是否被中断（检查中断标志），返回一个boolean但不清除中断状态。
class MyThread implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("i="+(i+1));
        }
    }
}
class MyThreadDemo{
    public static void main(String[] args){
        MyThread mt=new MyThread();
        Thread t1=new Thread(mt);
        t1.start();
        //给线程t1设置中断状态
        t1.interrupt();
        //判断线程t1是否被中断，但不清除中断标志：返回true
        System.out.println("第一次调用t1.isInterrupted()："+t1.isInterrupted());
        //判断线程t1是否被中断，但不清除中断标志：返回true
        System.out.println("第二次调用t1.isInterrupted()："+t1.isInterrupted());
        //判断当前线程（主线程）是否被中断：返回true
        System.out.println("第一次调用Thread.interrupted()："+ Thread.interrupted());
        //判断当前线程（主线程）是否被中断：返回true
        System.out.println("第二次调用Thread.interrupted()："+Thread.interrupted());
        //判断线程t1是否存活：线程t1被设置了中断标志，但并没有被中断，返回true
        System.out.println("t1是否存活："+t1.isAlive());

        //给当前线程（主线程）设置中断标志
        Thread.currentThread().interrupt();
        //判断当前线程（主线程）是否被中断，但不清除中断标志：返回true
        System.out.println("第一次调用Thread.currentThread().isInterrupted()："+Thread.currentThread().isInterrupted());
        //判断当前线程（主线程）是否被中断，并清除中断标志：返回true
        System.out.println("第三次调用Thread.interrupted()："+Thread.interrupted());
        //判断当前线程（主线程）是否被中断，因为中断标志已被清除：返回false
        System.out.println("第四次调用Thread.interrupted()："+Thread.interrupted());
    }
}

运行结果是：
在这里插入图片描述

2. 调用interrupt( )+对run( )做处理真正终止线程
class MyThread implements Runnable{
    public void run(){
        for(int i=0;i<1000;i++){
            System.out.println("i="+(i+1));
            if(Thread.currentThread().isInterrupted()){
                System.out.println("通过isInterrupted检测到中断");
                System.out.println("第一个interrupted():"+Thread.interrupted());
                System.out.println("第二个interrupted():"+Thread.interrupted());
                //检测到中断，退出循环，结束run()
                break;
            }
        }
        System.out.println("因为检测到中断，所以跳出循环，线程到这里结束");
    }
}
class MyThreadDemo{
    public static void main(String[] args) throws InterruptedException {
        MyThread mt=new MyThread();
        Thread t1=new Thread(mt);
        t1.start();
        t1.interrupt();
        //主线程等待1s，等线程t1运行完
        Thread.sleep(1000);
        //判断线程t1是否存活
        System.out.println("线程t1是否存活："+t1.isAlive());
    }
}

运行结果是：
在这里插入图片描述

又困了天哪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习笔记 - JavaSE基础
大湿的学徒的博客
07-28 776
123
Java等待所有的线程运行结束解决方案总结（8种）
热门推荐
dap769815768的博客
07-04 1万+
Java架构师交流群：793825326 java版本：jdk1.8 IDE：Idea2019 实际开发中，经常会碰到这种问题，某个线程需要等待所有的线程执行结束了，才可以继续执行。要实现这个效果，Java中有很多方案，下面我列举一些我所知道的方案： 方案一：join。代码如下： Thread thread1=new Thread(new Runnable() { ...
JavaSE基础语法--傻瓜笔记--1107(第五章:API_常用类2)
weixin_44734518的博客
11-10 231
第五章：API_常用类2 6.String类 1.构造方法，编码，解码 /* * 字符串就是由多个字符组成的一串数据的字符串 常量 ，在改变值时会创建一个新的对象。 * */ /* *构造方法，编码，解码 * */ public class StringDemo0 { public static void main(String[] args) throws UnsupportedEncodingException { String s0 = new Stri
Java笔记--实时更新
m0_52313753的博客
01-08 991
Java一学期复习前言一、Java开发入门1.1 Java概述1.2 JDK, JRE, JVM二、Java编程基础2.1 基本语法2.2 数据类型2.2.1八种基本数据类型2.3 运算符2.4 选 择结构2.5 循环结构三、面向对象四、常用类五、集合六、I/O流七、GUI八、JDBC九、多线程总结 前言 学了一学期Java了现在开始复习吧 一、Java开发入门 1.1 Java概述 Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言
javaSE笔记
weixin_44478522的博客
07-22 239
视频链接：https://www.bilibili.com/video/BV1Yb411z7PG?spm_id_from=333.337.search-card.all.click
[HotSpot 虚拟机垃圾收集调优指南-JavaSE11-笔记]-7-Garbage-First 垃圾收集器简介G1
宋小生-中间件
04-22 566
目录7-Garbage-First 垃圾收集器简介G17.1 Garbage-First 垃圾收集器简介7.2 启用 G17.3 基本概念7.4 堆布局7.5 垃圾回收周期7.6 垃圾优先内部7.7 G1 标记7.8 在非常紧张的堆情况下的行为7.9 巨大的对象7.10 年轻一代的大小Young-Only Phase Generation Sizing7.11 空间回收阶段分代的大小7.12 与其它垃圾收集器的比较 7-Garbage-First 垃圾收集器简介G1 7.1 Garbage-First 垃圾
JavaSE回顾笔记Ⅱ
skping
05-17 332
JavaSE回顾笔记Ⅱ ​ 本笔记为JavaSE的第二部分(共三部分）。虽然本笔记属于较为详细版本，但也是个人根据个人情况调整和精简过的。更适合学完每个小结后回顾而不是当初次的学习资料，否则可能会有遗漏一些简单的知识。另外也会有少量后面的知识整合到前面的情况。持续更新中。。。。 1.打字速度，80-100字母/分钟。 最低标准，要求手法正确。 2.JavaSE为Java的基础。要求会用，暂时不必过于深究一些不懂的知识，可以等到后期再研究。 3.面试中会问一些原理和底层。但用到的并不多，不过考虑到深造，
Java学习笔记整理-知识梳理+JDK1.8详细文档
qq_16726227的博客
11-27 2124
一、JavaSE 面向对象编程（Object-oriented programming） 1. 封装 1.1.类(class) 类的声明 两种类型的类声明: 普通类声明 class 类名 {} 枚举声明 enum 类名 {} PS:如果一个类与其任何包含的类或接口具有相同的简单名称，则是编译时错误。 类的构成 成员变量（属性），成员方法，构造方法，初始化块，静态块 1.2.对象 对象是类的具体实现。一切皆对象。 1.3.class和Java源文件的关系 类的 名称和Java源文件的名称必须保持一致 Java
学习笔记：黑马程序员Java-基础篇（第一部分）
最新发布
D_boj的博客
08-09 4100
本章介绍，Java概述、Java的HelloWorld案例、Java中基础语法、IDEA开发工具、运算符和表达式、控制语句、数组、代码块、关键字。Java内存模型、IDEA快捷键、以及常见Java基础的数据类型区分！
JavaSE专题-多线程总结.doc
06-03
多线程的常见问题总结分析 1、多线程技术介绍 2、主线程介绍 3、创建线程的方式 4、线程中的异常问题 5、线程运行状态 6、线程第二种创建方式 7、多线程练习 8、线程安全问题分析和解决 9、多线程细节 10、同步使用...
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
JavaSe笔记2021-8-2
08-02
JavaSe笔记2021-8-2
javase-学习笔记.pdf
11-28
javase-学习笔记.pdf
马士兵多线程笔记.zip
02-21
马士兵多线程训练营上课笔记
JavaSE笔记7.1-多线程-概述
qq_38503984的博客
02-04 1152
一. 进程和线程 进程：是一个正在执行中的程序。 每一个进程执行都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 二. Java的运行进程 javac.exe：Java的编译进程 java.exe：Java的运行进程 Java JVM启动的时候会有一个进程java.exe 该进程中至少有...
JavaSE笔记12-System类
qq_38503984的博客
08-18 910
JavaSE笔记12-System类1. 概述2. 系统属性信息 1. 概述 public final class System extends Object System类没有构造方法，不能被实例化 System类提供标准输入流System.in、标准输出流System.out、错误输出流System.err System类包含很多系统级的属性和控制方法，类中的方法都是静态的 2. 系统属性信息 （1）方法 //获取所有属性信息 public static Properties getProper
JavaSE笔记10.8-集合-Map
qq_38503984的博客
04-06 431
一. Map概述 1. 定义 Map是一种键-值对（key-value）集合，Map集合中的每一个元素都包含一个键（key）对象和一个值（value）对象，用于保存具有映射关系的数据。 Collection是单列集合，Map是双列集合 2. Map的特点 key和value都可以是任意引用类型的数据 key不允许重复，value可以重复 每个key可以映射到最多一个value 3. Map的常...
JavaSE笔记10.5-集合-HashSet
qq_38503984的博客
03-21 335
一. Set概述 1. Set的特点 元素是无序的；元素不可以重复。因为该集合体系无索引。 （无序：存入和取出的顺序不一定一致） 2. Set的功能 Set集合的功能和Collection是一致的 3. Set的子类 常见子类 （1）HashSet 底层数据结构是哈希表； （2）TreeSet 底层数据结构是二叉树； 二. HashSet底层数据结构 https://blog.csdn.net/w...
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
03-16
这是Oracle官网上Java SE 8的下载页面，其中提供了Java SE 8开发工具包（JDK）和Java SE 8运行时环境（JRE）的下载链接。用户可以根据自己的需要选择不同的平台和版本进行下载安装。注意，Java SE 8已经不再接收免费...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值