Java中停止线程、中断线程、等待状态（wait）（基础解析）

最新推荐文章于 2023-06-29 19:23:48 发布
最新推荐文章于 2023-06-29 19:23:48 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： Java 文章标签： 停止线程 中断线程 interrupt wait
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ssssssue/article/details/79284103
版权

http://blog.csdn.net/ssssssue

停止线程

测试interrupt中断线程
    测试interrupt中断线程

    public class Demo {
        public static void main(String[] args) {
            StopRunnable stopRunnable = new StopRunnable();
            Thread t1 = new Thread(stopRunnable);
            t1.start();
            // 给t1线程有执行时间
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            t1.interrupt();
            System.out.println("线程已中断");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("主线程结束");
        }
    }

    class StopRunnable implements Runnable {
        @Override
        public void run() {
            // 利用死循环 测试能不能停止线程
            while(true) {
                try {
                    // 沉睡1s
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                // 休眠1s(写个死循环 让循环执行1s结束)
                long time = System.currentTimeMillis();
                while (System.currentTimeMillis() - time < 1000) {

                }
                System.out.println(Thread.currentThread().getName() + "...run");
            }
        }
    }
    测试结果: 不能结束子线程
    实际上这个Interrupt() 方法
    设置了 isInterrupted 布尔值

    如果线程中有wait() 等待 或者 sleep 休眠
    这时 调用 interrupt方法
    会抛出一个异常 InterruptedException
    并且清除中断状态

    如果线程中没有等待 或者 休眠
    这时调用interrupt方法
    会设置中断状态(true/false的改变)
线程中没有等待或睡眠 调用interrupt方法中断线程
    public class Demo {
        public static void main(String[] args) {
            StopRunnable stopRunnable = new StopRunnable();
            Thread t1 = new Thread(stopRunnable);
            t1.start();
            // 给t1线程有执行时间
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            t1.interrupt();
            System.out.println("线程已中断");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("主线程结束");
        }
    }

    class StopRunnable implements Runnable {
        @Override
        public void run() {
            // 利用死循环 测试能不能停止线程
            while(!Thread.currentThread().isInterrupted) {

                // 休眠1s(写个死循环 让循环执行1s结束)
                long time = System.currentTimeMillis();
                while (System.currentTimeMillis() - time < 1000) {

                }
                System.out.println(Thread.currentThread().getName() + "...run");
            }
        }
    }
利用标记 停止线程
    利用标记 停止线程

    public class Demo {
        public static void main(String[] args) {
            StopRunnable stopRunnable = new StopRunnable();
            Thread t1 = new Thread(stopRunnable);
            t1.start();
            // 给t1线程有执行时间
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 利用标记 停止线程
            stopRunnable.isOver = true;
            System.out.println("线程已中断");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("主线程结束");
        }
    }

    class StopRunnable implements Runnable {
        public boolean isOver = false;

        @Override
        public void run() {
            // 利用死循环方式 测试能不能停止线程
            while(!isOver) {
                try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 休眠1s(写个死循环  让循环执行1s结束)
            long time = System.currentTimeMillis();
            while (System.currentTimeMillis() - time < 1000) {
            }
            System.out.println(Thread.currentThread().getName() + "...run");
            }
        }
    }

测试中断状态 wait方法

    public class Demo {
        public static void main(String[] args) {
            InterruptRunnable it = new InterruptRunnable();
            Thread t1 = new Thread(it);
            Thread t2 = new Thread(it);

            t1.start();
            t2.start();

            for (int i = 0; i < 50; i++) {
                if (i == 25) {
                    // 调用中断方法 来清楚状态
                    t1.interrupt();
                    t2.interrupt();
                    break;
                }
                System.out.println(i + "---");
            }
            System.out.println("主线程结束");
        }
    }

    class InterruptRunnable implements Runnable {
        public synchronized void run() {
            while(true) {
                try {
                    // 线程1进来 带着锁 遇到了wait方法 等待
                    //放弃了CPU的执行权 但是 锁 会还回去
                    // 线程2也带着锁进来 又遇到wait方法 也等待
                    // 相当于两个线程都在这里等待
                    // 进入冷冻(中断)状态
                    // 解决冷冻(中断)状态
                    // 调用interrupt方法 清除该状态
                    wait();
                    }catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...run");
            }
        }
    }
    这里利用interrupt方法 清除冷冻(中断)状态 
    不会中断线程会强行让线程继续运行
    所以报异常后还会打印一次
利用标记法
      public class Demo {
        public static void main(String[] args) {
            InterruptRunnable it = new InterruptRunnable();
            Thread t1 = new Thread(it);
            Thread t2 = new Thread(it);

            t1.start();
            t2.start();

            for (int i = 0; i < 50; i++) {
                if (i == 25) {
                    // 使用标记
                    it.isOver = true;
                    break;
                }
                System.out.println(i + "---");
            }
            System.out.println("主线程结束");
        }
    }

    class InterruptRunnable implements Runnable {
        public boolean isOver = fales;
        @Override
        public synchronized void run(){
            while(!isOver){
                try{
                    wait();
                }catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...run");
            }
        }
    }
    在使用标记法发现当到25的时候 程序不再打印 
    也不会像调用interrupt方法一样报异常
    但是也和调用interrupt方法一样 没有停止线程
    说明使用了wait方法 会让 线程等待 放弃了CPU的执行资源
    线程就会一直在这里等待
    如果想唤醒线程 我们需要调用 notify方法来唤醒线程
    wait方法 是 Object类的

    报的异常为:IllegalMonitorStateException
    这个异常解释中的对象监视器 就是 对象锁
    注意: wait方法 必须用锁对象去调用
注意
    interrupt方法 进来不要使用
    如果要停止线程 直接使用标记法停止
    只有遇到了 等待状态 时 可以使用 该方法
    强行清除该状态
小练习
    Person类 姓名 性别
    开启两个线程 
    一个对Person对象进行赋值
    一个对Person对象进行打印
    要求 一次打印 小明 男
         一次打印 xiaoming nv
         间隔输出


    public class Demo {
        public static void main(String[] args) {

        }
    }

    // Person类 姓名 性别
    class Person {
        public String name;
        public String gender;
        //声明标记 来切换 打印 和 赋值
    }

    // 赋值线程
    class SetRunnable implements Runnable {
        // 利用成员变量 操作同一个对象
        private Person p;
        // 定义一个标识 通过改变标识来进行间隔赋值
        Private boolean isTrue = true;

        // 利用构造方法来赋值
        public SetRunnable() {

        }
        public SetRunnable(Person p){
            this.p = p;
        }
        @Override
        public void run() {
            while(true) {
                //多个线程 操作共享数据
                // 添加同步锁 解决数据安全问题
                // 为了保证两个同步锁的锁对象相同 使用传进来的p的对象
                // 赋值线程 需要赋值完毕 打印线程才能去打印
                // 打印线程 打印完毕 才能让赋值线程 去赋值

                // 赋值的时候 打印线程 在等待 等赋值完成了 才能去打印
                // 打印完成后 通知复制线程 让复制线程继续赋值

                //wait 和 notify 使用一个标记来进行切换
                // 这个标记要给赋值线程使用 也要给打印线程使用
                // 必须保证使用的是同一个标记 标记声明在Person类中

                synchronized(p) {
                    // 先不进入等待 要先进行赋值
                    if(p.flag == true) {
                        // 进行等待
                        try{
                            p.wait();
                        }catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    // 间隔赋值
                    if(isTrue) {
                        p.name = "小明";
                        p.gender = "男";
                    }else{
                        p.name = "xiaoming";
                        p.gender = "nb";
                    }
                    // 改变标识符
                    isTrue = !isTrue;
                    // 修改标记
                    p.flag = true;
                    // 唤醒线程
                    p.notify();
                }
            }
        }
    }

    // 打印线程
    class PrintRunnable implements Runnable {
        // 利用成员变量 操作同一个对象
        private Person p;

        //利用构造方法 来赋值
        public PrintRunnable() {

        }
        public PrintRunnable(Person p) {
            this.p = p
        }
    }

    @Override
    public void run(){
        while(true){
            synchronized(p) {
                if(p.flag == false) {
                    // 进入等待
                    try{
                        p.wait();
                    }catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                // 打印名字 和 性别
                System.out.println(p.name + "..." + p.gender);
                // 修改标记
                p.flag = false;
                // 唤醒线程
                p.notify();
            }
        }
    }
稳健de少年
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程停止、中断最佳实践
wanghao112956的博客
09-03 550
如何正确停止线程 （想自学习编程的小伙伴请搜索圈T社区，更多行业相关资讯更有行业相关免费视频教程。完全免费哦!） 1. 讲解原理 原理介绍：使用interrupt来通知，而不是强制。 Java中停止线程的原则是什么? 在Java中，最好的停止线程的方式是使用中断interrupt, 但是这仅仅是会通知到被终止的线程“你该停止运行了”，被终止的线程自身拥有决定权(决定否、以及何时停止)，这依赖于请求...
Java之线程停止
碌人乘凉, 黎硕 --> Aerchi.com
01-17 105
Thread.stop、Thread.suspend、Thread.resume 和Runtime.runFinalizersOnExit 这些终止线程运行的方法已经被废弃，因为它存在安全隐患。 Java线程一般在执行完run方法就可以正常结束，不过有一类线程叫做伺服线程，不间断地执行，往往在run方法中有一个死循环，监视着某些条件，只有当这些条件满足时才能结束。例: Java代码 ...
Java 线程状态之 WAITING
chuifuhuo6864的博客
03-03 282
在这一篇章里，我们来看另一个重要的状态：WAITING（等待）。 定义 一个正在无限期等待另一个线程执行一个特别的动作的线程处于这一状态。 A thread that is waiting indefinitely for another thread to perform...
线程停止、中断
nothasson
01-12 898
线程停止、中断 原理 使用interrupt方法，去通知而不是强制 public class RightWayStopWithoutSleep implements Runnable { @Override public void run() { int num = 0; while (!Thread.currentThread().isInterrupted() && num < Integer.MAX_VALUE / 2) {
Java线程基础wait()、join()、sleep() 和 yield()
yinianzhijian99的专栏
04-23 641
Java thread wait()、join()、sleep() 和 yield()
Java Thread多线程详解及用法解析
09-01
- **interrupt()**：中断线程，线程在执行过程中可以检查是否被中断，并相应处理。 - **isAlive()**：检查线程是否处于活动状态。 - **isInterrupted()**：检查当前线程是否被中断。 - **interrupted()**：检查当前...
java多线程面试题59题集合
03-15
以下是对Java多线程面试题59题集合中可能涉及的一些关键知识点的详细解析。 1. **线程的创建方式** - 继承Thread类：创建一个新的类，该类继承自Thread类，并重写其run()方法。 - 实现Runnable接口：创建一个实现...
Java线程的相关方法详细解析
09-05
下面将对Java线程的主要方法进行详细解析： 1. **start()** - 这个方法是启动线程的关键，当你创建了一个`Thread`对象后，必须调用`start()`方法来启动它。这个方法会调用线程的`run()`方法，但区别在于`start()`会...
Java多线程-线程间的通信
最新发布
02-02
- **`wait()`**：使当前线程进入等待状态，直到被其他线程唤醒或等待超时。 - **`notify()`**：随机唤醒一个正在等待的线程。 - **`notifyAll()`**：唤醒所有正在等待的线程。 **示例代码**： ```java ...
Java系列深入解析Java多线程
09-22
- **线程状态**：Java线程有新建、就绪、运行、阻塞和死亡五种状态，理解这些状态有助于分析和解决问题。 - **优先级**：Java线程具有优先级，用于控制线程调度，但并不保证高优先级线程一定会先执行。 2. **创建...
java并发编程 4：线程的暂停唤醒 wait/notify与park/unpark
qq_43745578的博客
06-29 755
使用wait/notify与park/unpark实现线程的暂停和唤醒，即一些涉及的模式实现
并发编程 — 如何中断/停止一个运行中的线程？
搬运Gong
07-03 1146
如何中断/停止一个运行中的线程？
java高并发程序设计1-线程停下来（stop,wait,suspend,await,interrupt,join,yield，sleep）的操作
tangyuan_sibal的博客
03-21 974
写这一篇是因为这几个操作的使用和场景我也经常会记不住，所以写下这一篇文章来记录以后忘了可以翻一翻 1、第一组：被抛弃的stop,suspend stop: 如果你查看JDK中的Thread线程提供的stop()方法，可以发现已经被弃用了 而官方文档对它的说明是：这个方法会立即终止正在运行的线程，不管它处于什么样的状态，这会引起安全的异常。比如这样一个场景，你在对一个数据库进行插入数据操作的时候，...
Java中如何正确的终止线程
mahao25的博客
08-11 164
sleep,join,wait这样的阻塞方法都必须捕获一个InterruptedException异常，顾名思义就是一个线程中断的异常。 在java的线程Thread类中有三个方法，比较容易混淆，在这里解释一下 （1）interrupt：置线程的中断状态 （2）isInterrupt：线程是否中断 （3）interrupted：返回线程的上次的中断状态，并清除中断状态 package chapte...
java程序的生命周期_Java线程的生命周期
weixin_33711871的博客
02-17 202
概要目前CPU的运算速度已经达到了百亿次每秒，甚至更高的量级，家用电脑即使维持操作系统正常运行的进程也会有数十个，线程更是数以百计。线程是CPU的调度和分派的基本单位，为了更充分地利用CPU资源以及提高生产率和高效地完成任务，在现实场景中一般都会采用多线程处理。线程的生命周期线程的生命周期大致可以分为下面五种状态：New(新建状态)、RUNABLE(就绪状态)、RUNNING(运行状态)、休眠状态...
java中线程中断的方法
y_chengbo的博客
04-20 396
java中线程中断的方法Thread.join()Thread.sleep()Object.wait()CyclicBarrier.await()Thread.suspend() Thread.join() 假设此时有主线程main和子线程thread1，在main中启动thread1。如果thread1需要进行大量的计算工作，那么有可能main会先于thread1结束。当main需要用到thre...
java runnable 停止线程_Java中终止线程的方法详解
weixin_42348026的博客
02-13 7931
Java中终止线程的方式主要有三种：1、使用stop()方法，已被弃用。原因是：stop()是立即终止，会导致一些数据被到处理一部分就会被终止，而用户并不知道哪些数据被处理，哪些没有被处理，产生了不完整的“残疾”数据，不符合完整性，所以被废弃。So, forget it!2、使用volatile标志位看一个简单的例子：首先，实现一个Runnable接口，在其中定义volatile标志位，在run(...
java多线程之——停止线程多种方式
Xmumu_的博客
09-21 1348
hello，大家好这里是X，这里带来我总结的几种线程中断的方式，算是一个小合集~🚩
Java中的中断机制
吴就业
12-11 1625
在Java中，用于终止一个正在运行中的线程，并非调用stop方法，而是自行设置一个标志位，在安全点检测标志位，决定是否退出，但也可能会因为线程被挂起，无法走到标志位。因此，Java线程提供...
Java多线程基础与优势解析
线程的挂起与唤醒涉及到线程同步，例如使用wait()和notify()方法来控制线程的执行顺序和状态。 多线程编程中常见的问题包括竞态条件、死锁、活锁和饥饿等，解决这些问题通常需要正确的同步机制和设计模式，如使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值