JAVA多线程基础篇 3、如何优雅结束一个线程

已于 2022-03-11 17:15:35 修改
阅读量417 收藏 1
点赞数 1
分类专栏： JAVA多线程基础篇 文章标签： java java-ee 后端
于 2022-03-08 12:49:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EndlessProcess/article/details/123350870
版权

文章目录


线程的结束有几种类型

  • 寿终正寝，完成了使命，自然死亡。
  • 线程在执行的过程中，因为耗时过长或者各种原因被中断。

中断线程该如何处理呢？

1. 错误的方法

1.1 stop()方法不要使用

public class StopIsNotSafe {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(()->{
            while (true) {
                System.out.println("我在换衣服");
                System.out.println("我在脱裤子");
                System.out.println("我在穿裤子");
            }
        });

        t1.start();
        Thread.sleep(10);
        t1.stop();
    }
}

运行结果，脱了裤子没有穿，程序运行到一半：

stop方法

哪怕该线程正在执行某个事务，锁定了某个对象，此时仍然会被粗暴中止，往往此时程序正在做着重要的事情啊，一旦中止本应该完整的逻辑就被破坏了。

        Object o = new Object();
        Thread t2 = new Thread(()->{
            synchronized (o) {
                while (true) {
                    System.out.println("t2 我在换衣服");
                    System.out.println("t2 我在脱裤子");
                    System.out.println("t2 我在穿裤子");
                }
            }
        });

        t2.start();
        Thread.sleep(10);
        t2.stop();

运行结果，脱了裤子没有穿，程序运行到一半：

stop方法2

1.2 suspend() 也不建议使用

很简单，因为suspend方法调用后，线程会被暂停，但是锁资源仍然没有释放。
万一忘记resume()，或者调用resume时出现了问题，就会出现死锁。
况且这个方法并不是中断，只是暂停。

public class ResumeIsNotSafe {

    public static void main(String[] args) throws InterruptedException {

        Object o = new Object();

        Thread t1 = new Thread(()->{
            for(int i=0;i<5;i++) {
                synchronized (o) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("t1 :"+ LocalDateTime.now());
                }
            }
        });
        t1.start();

        Thread.sleep(100);
        t1.suspend();
        Thread.sleep(10000);
        //如果resume失效了。则无法执行t2了。
        System.out.println("此时，t1进入暂停状态，但是它仍然持有锁");
        //t1.resume();

        Thread t2 = new Thread(()->{
            for(int i=0;i<5;i++) {
                synchronized (o) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("t2 :"+ LocalDateTime.now());
                }
            }
        });
        t2.start();
    }
}

执行结果，t2线程无法获得锁，死锁:

suspend忘记resume

2.正确的方法

2.1 使用volatile + 标志位

有句话叫做“凯撒的归凯撒，上帝的归上帝”，线程自己的事情，应该由线程自己控制。
我们可以在线程类内部设定一个flag字段，主线程通过该字段能够通知t1线程，线程监控该字段，当该字段为True，则线程正常运行，否则就停下来。

public class UsingFlagToStop {

    private static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {

        //线程t1每秒打印一次
        Thread t1 = new Thread(()->{
            while (flag) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1:"+ LocalDateTime.now());
            }
        });

        t1.start();
        Thread.sleep(4000);
        flag=false;
    }
}

执行结果如下，当主线程4秒后设置flag为false后，t1线程检测到标志被设置，于是停止了运行。

suspend忘记resume

不足之处 ，volatile标志位无法及时通知正在wait()和sleep()的线程。

2.2 使用线程的interrupt()方法

了解关于interrupt有关的三个方法。

  • void interrupt() ，例如t1.interrupt()，通过设置t1线程的中断标志通知线程。此时线程会接收到InterruptedException异常，从而进行控制。
  • boolean isInterrupted() 线程可以通过该方法查询自身的中断标志。
  • static boolean interrupted() ，该方法是静态方法，查看线程当前的中断的标志，如果是被打断状态，会重置恢复标志。

2.2.1 方式1、interrupt() 后进入Exception处理。

interrupt的java内置的解决方案，能够在wait()和sleep()时，及时通知，更加优雅有效。
线程t1 一开始运行后,就睡眠，通过调用t1.interrupt()，将t1打断，不用等那么久了。

public class InterruptToStop {

    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        Thread t1 = new Thread(()->{
            synchronized(o) {
                System.out.println(LocalDateTime.now()+" t1:等等我先喝口水上个厕所");
                try {
                    Thread.sleep(10000);
                    //对于正在wait的线程也可以中断哦。
                    //o.wait();
                } catch (InterruptedException e) {
                    System.out.println(LocalDateTime.now()+" t1:摸鱼的我，被打断了，赶紧善后。");
                }
                System.out.println(LocalDateTime.now()+" t1:事情忙完了。");
            }
        });

        Thread t2 = new Thread(()->{
            synchronized(o) {
                System.out.println(LocalDateTime.now()+" t2:终于轮到我上场了");
            }
        });

        t1.start();
        //确保t1先启动，拿到锁对象o。
        Thread.sleep(50);
        t2.start();
        t1.interrupt();
    }
}

运行结果显示，t1被打断后，进入异常处理环节，在这里实现更加优雅的打断。

interrupt

2.2.2 方式2、线程不断检查自身中断状态。

也可以通过线程检查自身interrupted状态来控制。
这种方式适用于线程内部没有调用wait、sleep等方法的情况下。因为在这种情况下，是没有对InterruptedException进行特殊处理。所以需要线程不断检查interrupted状态。

public class InterruptToStop2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while (!Thread.interrupted()) {
                System.out.println("t1 处理事情 "+ LocalDateTime.now());
            }
            System.out.println("我被打断了，做后面的事情");
        });
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
    }
}

运行结果，t1检查到被interrupt，被中断。

interrupt2

2.3 如何打断正在抢锁（BLOCKED）状态的线程

interrupt()方法对于正在抢锁的线程是无能为力的。

做一个实验，线程进入blocked状态后，通过interrupt打断，没有效果。

public class InterruptToStop3 {
    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        Thread t1 = new Thread(()->{
            synchronized (o) {
                System.out.println(LocalDateTime.now()+",t1:我获得了锁，我将占有10秒钟");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        //保证t1先执行
        Thread.sleep(50);

        Thread t2 = new Thread(()->{
            System.out.println(LocalDateTime.now()+",t2 我将争抢锁");
           synchronized (o) {
               System.out.println(LocalDateTime.now()+",t2:我终于抢到锁了");
           }
        });
        t2.start();

        Thread.sleep(50);
        System.out.println("t2 状态："+ t2.getState());
        //此时无法打断。进入blocked状态。
        t2.interrupt();
    }
}

运行结果，t2非要拿到锁后继续执行。感觉是一个很执拗的线程。

interrupt和抢锁1

解决方案是，使用ReentrantLock锁对象，调用lockInterruptibly()方法加锁。

public class InterruptToStop4 {
    public static void main(String[] args)  {
        ReentrantLock o = new ReentrantLock();
        Thread t1 = new Thread(()->{
            try {
                o.lock();
                System.out.println(LocalDateTime.now()+",t1:我获得了锁，我将占有10秒钟");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {

                }
            } finally {
                o.unlock();
            }
        });
        t1.start();

        //保证t1先执行
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            //e.printStackTrace();
        }

        Thread t2 = new Thread(()->{
            System.out.println(LocalDateTime.now()+",t2 我将争抢锁");
            try {
                o.lockInterruptibly();
                System.out.println(LocalDateTime.now()+",t2 我终于拿到锁啦！！！");

            } catch (InterruptedException e) {
                System.out.println(LocalDateTime.now()+",t2 我被中断了！");
            }finally {
                if(o.isHeldByCurrentThread())
                o.unlock();
            }
        });
        t2.start();
        //保证t1先执行
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            //e.printStackTrace();
        }
        System.out.println("t2 状态："+ t2.getState());
        //此时无法打断。进入blocked状态。
        t2.interrupt();
    }
}

运行结果显示，此时可以中断正在抢锁的线程。而且该线程其实并没有进入BLOCKED状态，而是WATING状态。也就是说JAVA对这种抢锁的方式，其处理方法是有不同的。
运行结果:
interrupt和抢锁2

总结

  • 对于线程中断的处理要交给线程自身。
  • 可以自己定义标志位来处理。
  • 也可以使用interrupt方法来处理，它能适应的场景很多，在线程sleep()、wait()，甚至抢锁时都能中断。

多线程系列在github上有一个开源项目，主要是本系列博客的实验代码。

https://github.com/forestnlp/concurrentlab

如果您对软件开发、机器学习、深度学习有兴趣请关注本博客，将持续推出Java、软件架构、深度学习相关专栏。

您的支持是对我最大的鼓励。

悟空学编程
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java中终止一个线程的方法总结（精）
11-02
不客气地说，至少有一半人认为，线程的“中断”就是让线程停止。如果你也这么认为，那你对多线程编程还没有入门。 　　在java中，线程的中断(interrupt)只是改变了线程的中断状态，至于这个中断状态改变后带来的结果，那是无法确定的，有时它更是让停止中的线程继续执行的唯一手段。不但不是让线程停止运行，反而是继续执行线程的手段。
java多线程学习之七—如何优雅的停止线程（池）
伍六七的博客
02-27 867
文中内容整理自《Java并发编程实战》 方法一：使用中断标志 使用 cancelled 标志，当标志状态为true的时候，停止线程。 示例： public class Test0701CancelThread implements Runnable { public static void main(String[] args) { Test0701CancelThread cancelThread = new Test0701CancelThread(); try
Java 优雅的终止线程
热门推荐
Roy的IT笔记
06-13 2万+
Java中原来在Thread中提供了stop()方法来终止线程，但这个方法是不安全的，所以一般不建议使用。《Java多线程模式》中有一种叫Two-Phase Termination（两步终止）的模式可以优雅的终止线程。 首先在线程中设置一个标志位： private volatile boolean shutdownRequested = false; 然后在运行函数里，以这个标志位来
java 如何优雅的停止一个线程
shengjk1的博客
01-08 564
写过多线程的童鞋，可能都会遇到一个问题，那就是线程如何优雅的停止！ 1.通过 标志位 来终止线程 private static class Runner implements Runnable{ private long i; private (volatile) boolean running =true; @Override public void run() { Sys...
Java中如何优雅的结束线程
weixin_34161083的博客
07-21 54
http://blog.csdn.net/xplee0576/article/details/45133791 浅析Java线程的正确停止 http://blog.csdn.net/luoxinwu123/article/details/7660625Java 优雅的终止线程 收藏在这里算了留个记录吧！ 转载于:https://www.cnblogs.com/silianbo/p/4665...
JAVA如何优雅地停止一个线程_如何优雅地停止一个线程？
weixin_39690391的博客
02-24 151
线程终止有两种情况：1、线程的任务执行完成2、线程在执行任务过程中发生异常这两者属于线程自行终止，如何让线程 A 把线程 B 终止呢？Java 中 Thread 类有一个 stop() 方法，可以终止线程，不过这个方法会让线程直接终止，在执行的任务立即终止，未执行的任务无法反馈，所以 stop() 方法已经不建议使用。既然 stop() 方法如此粗暴，不建议使用，我们如何优雅地结束线程呢？线程只有...
Java多线程之基础篇(一).docx
04-16
与此相反，像java所使用的这种并发系统会共享内存或I/O这样的资源，因此编程编写多线程程序最基本的困难在于，协调不同线程驱动的任务之间这些资源的使用，以便使得这些资源不会同时被多个任务访问。
一篇文章弄懂Java多线程基础和Java内存模型
12-21
文章目录一、多线程的生命周期及五种基本状态二、Java多...本篇文章将分为两部分第一部分是讲解多线程基础、第二部分讲解Java内存模型。 一、多线程的生命周期及五种基本状态 Java多线程生命周期，首先看下面这张经典
Java第九章多线程程序设计基础篇.ppt
11-13
Java第九章多线程程序设计基础篇.ppt
Java多线程之基础篇(二).docx
04-16
与此相反，像java所使用的这种并发系统会共享内存或I/O这样的资源，因此编程编写多线程程序最基本的困难在于，协调不同线程驱动的任务之间这些资源的使用，以便使得这些资源不会同时被多个任务访问。
【java】多线程终止
lzm18064126848的专栏
04-03 448
Java Thread Primitive Deprecation Why is Thread.stop deprecated? 因为它本质上是不安全。停止线程会使其释放所有已锁定的监视器。（当ThreadDeath异常传播到堆栈时，监视器将被解锁。）如果先前受这些监视器保护的任何对象处于不一致状态，则其他线程现在可能会以不一致的状态查看这些对象。这个时候对象就已经被破坏了。当线
java线程暂停用什么_如何优雅地停止java线程？
weixin_33096511的博客
02-17 176
使用标志停止线程的坏处在于，如果线程正在等待或处于休眠状态，则必须等待它完成等待/休眠。如果您调用线程上的中断方法，那么这将导致等待或睡眠调用与InterruptedException一起退出。(标志方法的第二个缺点是，大多数非平凡的代码都将使用java.util.current这样的库，其中的类是专门设计用来使用中断来取消的。在传递给Executir的任务中使用手摇标志将很尴尬。)调用中断()还...
thread java 结束_Java开发Thread使用优雅方式结束线程
weixin_39869197的博客
02-21 152
方式一设置一个是否结束的标志(开关)。packagecom.example.threaddesign;/***@authorDongguabai*@date2018/12/415:16*/publicclassStopThread1{privatestaticvolatilebooleanstop=true;publicstaticvoidmain(String...
【Java并发编程】如何优雅的结束一个线程
love and share
06-06 308
使用两阶段终止来优雅地结束一个线程
java结束一个线程_如何优雅地结束一个线程？
weixin_39616547的博客
02-21 272
首先谢谢邀请在本文中，我们将讨论结束Java线程的简洁方法，这是必要的，因为Java已经弃用了Thread.stop()方法。Thread.stop, Thread.suspend, Thread.resume and Runtime.runFinalizersOnExit由于一些潜在的线程安全问题， Oracle已弃用 。很少有公认的和广为接受的方法来实现这一点，在本文中，我们将讨论2 个用Ja...
多线程_终止
weixin_43003240的博客
02-21 242
package com.sxt.state; /** * 终止线程 1、线程正常执行完毕--&amp;gt;次数 2、外部干涉--&amp;gt;加入标识 不要使用stop、destroy * * @author * */ public class TerminateThread implements Runnable { // 1、加入标识 标记线程体是否可以运行 private boole...
多线程的终止
再来一块红烧肉
03-31 174
我们为什么需要线程终止？ stop()/destroy() 标志位法
【三】Java多线程确定线程结束（isAlive、join）
Sid小杰的博客
08-11 1273
知道线程结束的方法 1.isAlive public class MoreThread extends Thread { int count; String thrdName; MoreThread(String name){ count = 0; thrdName = name; } @Override pu...
在Java中如何用interrupt优雅的结束线程
warmor的专栏
07-17 287
一般来说线程执行完run()之后就自动结束了，不过有些时候我们需要线程不停的做一些事情，也就是使用while循环，那么这时候该如何停止线程呢？ 这个问题需要分情况来讨论，如果线程做的事情不是耗时的，那么只需要使用一个标志即可，具体的代码如下： class MyThread extends Thread { private volatile boolean isStop = false; public void run() { ...
帮我写一个java多线程的博文
最新发布
09-13
希望这篇博文能够为你提供一个好的起点来学习Java多线程！ ### 回答2： 当下，计算机领域近年来最具热度和应用广泛的概念之一便是多线程编程。多线程编程是指在一个程序中同时执行多个线程，每个线程都是独立运行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悟空学编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值