精华内容
下载资源
问答
  • Java线程中断与终止线程运行
    2021-03-14 01:00:06

    Java中启动一个线程很容易,通常情况下我们都是等到任务运行结束后让线程自行停止。但有时需要在任务正在运行时取消他们,使得线程快速结束。对此Java并没有提供任何机制。但是我们可以通过Java提供的线程中断机制来实现。

    首先来看Thread类三个和中断有关的方法:

    public class Thread {

    // 发出一个中断请求,把标志位设定为中断状态,不会终止线程运行。

    // 其他线程试图调用该方法,会检测是否有权限中断该线程(正常情况

    // 下不会存在权限问题,这里可以忽略)

    public void interrupt() { ... }

    // 检测标志位是否为中断的状态

    public boolean isInterrupted() { ... }

    // 清除当前线程的标志位的中断状态,返回是否为中断状态

    public static boolean interrupted() { ... }

    ...

    }

    既然线程中断不会终止线程的运行,那么如何通过线程中断来实现终止线程运行呢?

    我们知道一些阻塞线程的方法会抛出InterruptedException表示线程中断发生,在这种情况下就可以使用线程中断来终止线程的运行:

    public class TestInterrupt {

    public static void main(String[] args)

    {

    BlockingQueue ObjectQueue = new LinkedBlockingQueue();

    Consumer consumer = new Consumer(ObjectQueue);

    Thread t = new Thread(consumer);

    t.start();

    // 等待线程的启动

    try

    {

    Thread.sleep(1000);

    }

    catch (InterruptedException e)

    {

    e.printStackTrace();

    }

    // 中断线程

    t.interrupt();

    }

    }

    class Consumer implements Runnable

    {

    private final BlockingQueue ObjectQueue;

    public Consumer(BlockingQueue ObjectQueue)

    {

    if (ObjectQueue == null)

    {

    throw new IllegalArgumentException("messageQueue cannot be null");

    }

    this.ObjectQueue = ObjectQueue;

    }

    @Override

    public void run()

    {

    boolean isRunning = true;

    while (isRunning)

    {

    try

    {

    // take方法阻塞时会因为线程中断抛出中断异常

    System.out.println(ObjectQueue.take());

    }

    catch (InterruptedException e)

    {

    // 一旦抛出中断异常,线程的中断状态就会被清除,这个时候调用

    // Thread的isInterrupted()方法返回的是false

    isRunning = false;

    System.out.println("Cancelled");

    }

    }

    }

    }

    很多任务执行的服务程序的逻辑和上面的例子很类似,都可以使用这种方法来终止线程的运行。

    原文出自:http://www.cnblogs.com/wanly3643/p/3992186.html

    更多相关内容
  • 线程如何停止 ...使用 interrupt 方法中断线程(这里只是中断标志)。 interrupt() 方法并不像在 for 循环语句中使用 break 语句那样干脆,马上就停止循环。调用 interrupt() 方法仅仅是在当前线程中

    线程如何停止

    停止一个线程通常意味着在线程处理任务完成之前停掉正在做的操作,也就是放弃当前的操作。

    三种方式:

    1. 使用退出标志,使线程正常退出,也就是当 run() 方法完成后线程中止。
    2. 使用 stop() 方法强行终止线程,但是该方法已被弃用(强制停止,会导致一些使用的资源未得到释放…)
    3. 使用 interrupt 方法中断线程(1.使用标志 2.使用异常捕获 )。

    interrupt() 方法并不像在 for 循环语句中使用 break 语句那样干脆,马上就停止循环。调用 interrupt() 方法仅仅是在当前线程中打一个停止的标记,并不是真的停止线程。

    也就是说,线程中断并不会立即终止线程,而是通知目标线程,有人希望你终止。

    使用interrupt 方法停止线程

    通过异常捕获来中断异常
    打标记

    public class ThreadDemo1 {
        public static void main(String[] args) throws InterruptedException {
            // 线程的中断
            Thread t1 = new Thread(new MyRunnable());
            t1.start();
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                Thread.sleep(1000);
            }
            // 线程中断标记
            t1.interrupt();
        }
    }
    class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现了中断标记,但是我们就是不死亡");
                }
            }
        }
    }
    

    结果:

    main:0
    Thread-0:0
    main:1
    Thread-0:1
    main:2
    Thread-0:2
    main:3
    Thread-0:3
    main:4
    Thread-0:4
    Thread-0:5
    发现了中断标记,但是我们就是不死亡
    Thread-0:6
    Thread-0:7
    Thread-0:8
    Thread-0:9
    

    让线程中断死亡

    public class ThreadDemo1 {
        public static void main(String[] args) throws InterruptedException {
            // 线程的中断
            Thread t1 = new Thread(new MyRunnable());
            t1.start();
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                Thread.sleep(1000);
            }
            // 线程中断
            t1.interrupt();
        }
    }
    class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现了中断标记,线程死亡");
                    // 在这里就可以进行一些资源释放操作...
                    return;
                }
            }
        }
    }
    

    结果:

    main:0
    Thread-0:0
    Thread-0:1
    main:1
    main:2
    Thread-0:2
    Thread-0:3
    main:3
    main:4
    Thread-0:4
    Thread-0:5
    发现了中断标记,线程死亡
    

    所以需要使用如下方法
    通过检查标志位

    方法:这两个方法使得当前线程能够感知到是否被中断了

    方法描述
    public boolean Thread.isInterrupted()判断是否被中断
    public static boolean Thread.interrupted()判断是否被中断,并清除当前中断状态
     public static void main(String[] args) throws InterruptedException {
    
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
    
                        // 判断是否有中断标志
                        if (Thread.interrupted()) {
                            System.out.println("线程被中断");
                            break;
                        }
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("线程执行"+ i);
                    }
                }
            });
            thread.start();
            Thread.sleep(10);
            thread.interrupt();
            for (int i = 0; i < 10; i++) {
    
                System.out.println("main"+i);
            }
        }
    

    结果

    main0
    线程执行0
    main1
    线程被中断
    main2
    main3
    main4
    main5
    main6
    main7
    main8
    main9
    
    展开全文
  • 之前在使用Java实现熔断降级组件的时候,需要实现接口请求的超时中断,通过查找相关资料了解了相关的方法,下面这篇文章主要给大家介绍了关于Java中实现线程的超时中断的相关资料,需要的朋友可以参考下
  • Java线程中断

    2021-03-08 09:46:35
    线程中断线程中断即线程运行过程中被其他线程给打断了,它与stop最大的区别是:stop是由系统强制终止线程,而线程中断则是给目标线程发送一个中断信号,如果目标线程没有接收线程中断的信号并主动结束线程,线程则...

    线程中断

    线程中断即线程运行过程中被其他线程给打断了,它与stop最大的区别是:stop是由系统强制终止线程,而线程中断则是给目标线程发送一个中断信号,如果目标线程没有接收线程中断的信号并主动结束线程,线程则不会终止。具体是否退出或执行其他逻辑则由目标线程自行决定。

    线程状态

    一般地,操作系统线程有如下四种状态:

    (1)New新生/创建   (2)Runnable可运行   (3)Blocked阻塞/挂起    (4)Dead死亡

    值得注意的是,线程的可运行状态并不代表线程一定在运行(runnable不等于running) 操作系统使用了抢占式的线程调度策略。一旦线程开始执行,并不是总是保持持续运行状态的。当系统分给它的时间片(非常小的运行时间单位)用完以后,不管程序有没有执行完,线程都将放弃CPU,进入就绪状态,直到下次被调度后开始继续执行。也就是说,Runnable可运行状态的线程处于两种可能的情况下:(1)占用CPU运行中   (2)等待调度的就绪状态。

    这里要声明一下,处于等待调度的就绪状态的线程和处于阻塞状态的线程是完全不同的。就绪状态的线程是因为时间片用完而放弃CPU,随时都有可能再次获得CPU运行,取决于分时OS的线程调度策略。

    在很多操作系统中,这种因时间片用完而被剥夺CPU的情况我们叫做线程中断。注意这和我们下面要将得中断线程是两个完全不同的概念。事实上,我们不可能通过应用程序来控制CPU的线程中断,除非我们能够自由调用OS的内核。

    中断线程 —— interrupt()

    一个正在运行的线程除了正常的时间片中断之外,能否被其他线程控制?或者说其他线程能否让指定线程放弃CPU或者提前结束运行? 除了线程同步机制之外,还有两种方法:

    (1)Thread.stop(), Thread.suspend(), Thread.resume()和Runtime.runFinalizersOnExit()这些终止线程运行的方法 。这些方法已经被废弃,因为使用它们是不安全的。

    (2)Thread.interrupt()方法是很好的选择。但是使用的时候我们必须好好理解一下它的用处。

    Java代码

    //无法中断正在运行的线程代码

    class TestRunnable implementsRunnable{public voidrun(){while (true){

    System.out.println("Thread is running...");//去系统时间的毫秒数

    long time =System.currentTimeMillis();while ((System.currentTimeMillis() - time < 1000)){//程序循环1秒钟,不同于sleep(1000)会阻塞进程。

    }

    }

    }

    }public classThreadDemo{public static voidmain(String[] args){

    Runnable r=newTestRunnable();

    Thread th1=newThread(r);

    th1.start();

    th1.interrupt();

    }

    }

    /运行结果:一秒钟打印一次Thread is running...。程序没有终止的任何迹象

    上面的代码说明interrupt()并没有中断一个正在运行的线程,或者说让一个running中的线程放弃CPU。那么interrupt到底中断什么。

    首先我们看看interrupt究竟在干什么。

    当我们调用th1.interrput()的时候,线程th1的中断状态(interrupted status)会被置位。我们可以通过Thread.currentThread().isInterrupted()来检查这个布尔型的中断状态。

    在Core Java中有这样一句话:"没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断 "。好好体会这句话的含义,看看下面的代码:

    //Interrupted的经典使用代码

    public voidrun() {try{

    .../** 不管循环里是否调用过线程阻塞的方法如sleep、join、wait,这里还是需要加上

    * !Thread.currentThread().isInterrupted()条件,虽然抛出异常后退出了循环,显

    * 得用阻塞的情况下是多余的,但如果调用了阻塞方法但没有阻塞时,这样会更安全、更及时。*/

    while (!Thread.currentThread().isInterrupted()&& more work to do) {domore work

    }

    }catch(InterruptedException e) {//线程在wait或sleep期间被中断了

    } finally{//线程结束前做一些清理工作

    }

    }

    很显然,在上面代码中,while循环有一个决定因素就是需要不停的检查自己的中断状态。当外部线程调用该线程的interrupt 时,使得中断状态置位。这是该线程将终止循环,不在执行循环中的do more work了。

    这说明: interrupt中断的是线程的某一部分业务逻辑,前提是线程需要检查自己的中断状态(isInterrupted())。但是当th1被阻塞的时候,比如被Object.wait,Thread.join和Thread.sleep三种方法之一阻塞时。调用它的interrput()方法。可想而知,没有占用CPU运行的线程是不可 能给自己的中断状态置位的,这就会产生一个InterruptedException异常。

    //中断一个被阻塞的线程代码

    class TestRunnable implementsRunnable{public voidrun(){try{

    Thread.sleep(1000000); //这个线程将被阻塞1000秒

    }catch(InterruptedException e){

    e.printStackTrace();//do more work and return.

    }

    }

    }public classTestDemo2{public static voidmain(String[] args) {

    Runnable tr= newTestRunnable();

    Thread th1= newThread(tr);

    th1.start();//开始执行分线程

    while ( true){

    th1.interrupt();//中断这个分线程

    }

    }

    }

    注意:synchronized在获锁的过程中是不能被中断的,意思是说如果产生了死锁,则不可能被中断(请参考后面的测试例子)。与synchronized功能相似的reentrantLock.lock()方法也是一样,它也不可中断的,即如果发生死锁,那么reentrantLock.lock()方法无法终止,如果调用时被阻塞,则它一直阻塞到它获取到锁为止。但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit),那么如果线程在等待时被中断,将抛出一个InterruptedException异常,这是一个非常有用的特性,因为它允许程序打破死锁。你也可以调用reentrantLock.lockInterruptibly()方法,它就相当于一个超时设为无限的tryLock方法。

    参考资料

    https://blog.csdn.net/xinxiaoyong100440105/article/details/80931705

    展开全文
  • Java 停止线程

    2021-04-22 17:12:14
    1概述在Java中有以下3种方法可以终止正在运行的线程:1)当run方法完成后线程终止。2)使用stop方法强行终止线程,...3)使用interrupt方法中断线程。2 stop()方法停止线程try {MyThread thread = new MyThread();threa...

    1概述

    在Java中有以下3种方法可以终止正在运行的线程:

    1)当run方法完成后线程终止。

    2)使用stop方法强行终止线程,但是不推荐使用这个方法,因为stop和suspend及resume一样,都是作废过期的方法,使用它们可能产生不可预料的结果。

    3)使用interrupt方法中断线程。

    2 stop()方法停止线程

    try {

    MyThread thread = new MyThread();

    thread.start();

    Thread.sleep(8000);

    thread.stop();

    } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    调用stop()方法时会抛出java.lang.ThreadDeath异常,但在通常的情况下,此异常不需要显式地捕捉。

    调用stop()方法后线程会立即停止

    问题

    方法stop()已经被作废,因为如果强制让线程停止则有可能使一些清理性的工作得不到完成。

    另外一个情况就是对锁定的对象进行了“解锁”,导致数据得不到同步的处理,出现数据不一致的问题。

    3 调用interrupt()方法来停止线程

    设置线程的中断状态

    interrupt()方法的使用效果并不像for+break语句那样,马上就停止循环。

    调用interrupt()方法仅仅是在当前线程中打了一个停止的标记,并不是真的停止线程。

    3.1 this.interrupted() VS this.isInterrupted()

    this.interrupted():测试当前线程是否已经是中断状态,执行后具有将状态标志置清除为false的功能。

    this.isInterrupted():测试线程Thread对象是否已经是中断状态,但不清除状态标志。

    3.2 interrupt方法配合抛出异常停止线程

    建议使用“抛异常”的方法来实现线程的停止,因为在catch块中还可以将异常向上抛,使线程停止的事件得以传播。

    【Java 多线程】Java中主线程如何捕获子线程抛出的异常

    public class MyThread extends Thread {

    @Override

    public void run() {

    super.run();

    try {

    for (int i = 0; i < 500000; i++) {

    if (this.interrupted()) {

    System.out.println("已经是停止状态了!我要退出了!");

    throw new InterruptedException();

    }

    System.out.println("i=" + (i + 1));

    }

    System.out.println("我在for下面");

    } catch (InterruptedException e) {

    System.out.println("进MyThread.java类run方法中的catch了!");

    e.printStackTrace();

    }

    }

    }

    public class Run {

    public static void main(String[] args) {

    try {

    MyThread thread = new MyThread();

    thread.start();

    Thread.sleep(2000);

    thread.interrupt();

    } catch (InterruptedException e) {

    System.out.println("main catch");

    e.printStackTrace();

    }

    System.out.println("end!");

    }

    }

    c986e7383784

    qq_pic_merged_1534415736719.jpg

    3.3 interrupt方法 配合 return 停止线程

    程序正常执行完成,线程退出。

    public class MyThread extends Thread {

    @Override

    public void run() {

    while (true) {

    if (this.isInterrupted()) {

    System.out.println("停止了!");

    return;

    }

    System.out.println("timer=" + System.currentTimeMillis());

    }

    }

    }

    public class Run {

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

    MyThread t=new MyThread();

    t.start();

    Thread.sleep(2000);

    t.interrupt();

    }

    }

    c986e7383784

    qq_pic_merged_1534415883582.jpg

    3.4 注意

    如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法,或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻,则其中断状态将被清除,它还将收到一个 InterruptedException。

    如果该线程在可中断的通道上的 I/O 操作中受阻,则该通道将被关闭,该线程的中断状态将被设置并且该线程将收到一个ClosedByInterruptException。

    参考

    《java多线程编程核心技术》

    展开全文
  • Java的interrupt中断线程详解

    千次阅读 2020-03-17 22:58:22
    主要讲解Java interrupt线程中断,以及停止线程的方式,并且进行了相关的代码演示。
  • Java 程序中有不止一条执行线程,只有当所有的线程都运行结束...线程中断线程运行过程中被其他线程给打断了,它与 stop 最大的区别是:stop 是由系统强制终止线程,而线程中断则是给目标线程发送一个中断信号,如...
  • 一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果比如会带着自己所持有的锁而永远的休眠,迟迟不归还锁等。 所以你看到Thread.suspend, Thread.stop等方法都被Deprecated...
  • Java中出现线程中断的原因有哪些发布时间:2021-02-19 15:31:06来源:亿速云阅读:59作者:Leah这篇文章将为大家详细讲解有关Java中出现线程中断的原因有哪些,文章内容质量较高,因此小编分享给大家做个参考,希望...
  • Java中的线程在运行的时候,有办法强制...正确的、优雅的中断线程的方式应该是给线程发出中断信号(即调用线程实例的interrupt方法,用余春龙大佬的话来说,interrupt这个词很容易让人产生误解,从字面含义看好像是线程
  • Java中终止线程的三种方法

    千次阅读 2021-02-26 20:57:55
    终止线程一般建议采用的方法是让线程自行结束,进入Dead(死亡)状态,就是执行完run()方法。...第一种 使用Thread类提供的stop()方法或suspend()方法强制终止线程(不安全,不要用)第二种 使用volatile标记位退出线程...
  • 详解Java 线程中断

    2021-03-16 11:56:33
    一、前言大家肯定都使用过 Java 线程开发(Thread / Runnable),启动一个线程的做法通常是:new Thread(new Runnable(@Overridepublic void run() {// todo sth...})).start();然而线程退出,大家是如何做的呢?一般...
  • ③使用中断机制t.stop()调用时,终止线程,会导致该线程所持有的锁被强制释放,从而被其他线程所持有,因此有可能导致与预期结果不一致。下面使用中断信号量中断非阻塞状态的线程中:public class TestStopThread {...
  • java中怎么强行终止一个线程的执行。 这种方式存在很大的缺点:容易丢失数据。因为这种方式是直接将线程杀死了, 线程没有保存的数据将会丢失。不建议使用。 */ public class ThreadTest09 { public static ...
  • 这篇文章主要记录使用 interrupt() 方法中断线程,以及如何对InterruptedException进行处理。感觉对InterruptedException异常进行处理是一件谨慎且有技巧的活儿。 由于使用stop()方法停止线程非常的暴力,人家线程...
  • java中断线程

    2018-05-17 16:17:28
    Java 的早期版本中 , 还有一个 stop 方法 , 其他线程可以调用它终止线程。 但是 , 这个方法现在已经被弃用了 。没有可以强制线程终止的方法。 然而 , interrupt 方法可以用来请求终止线程 。当对一个线程...
  • java线程退出

    2021-04-17 07:11:13
    它的作用是,在线程受到阻塞时抛出一个中断信号,这样线程就得以退出阻塞的状态。更确切的说,如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞,那么,它将接收到一个中断异常(In...
  • Java停止线程的3种方式

    千次阅读 2022-03-04 11:12:43
    使用interrupt方法中断线程。 使用标志位 在 run() 方法执行完毕后,该线程就终止了。但是在某些特殊的情况下,run() 方法会被一直执行;比如在服务端程序中可能会使用 while(true) { … } 这样的循环结构来不断的...
  • 今天刚好有位同事问我,用Java请求Http的时候,有时候不希望阻塞太长时间,想做个监视然后可以中断请求的。他的请求是放在独立线程中的,那么怎样中断一个请求?我们先看看Thread的interrupt方法,能否做到这...
  • 主要介绍了Java并发编程示例(三):线程中断,在本节,我们所开发的示例程序将会创建一个线程,五秒钟后,利用中断机制强制中止这个线程,需要的朋友可以参考下
  • 使用interrupt方法中断线程。 使用标志位来停止线程: /** * 使用状态标记来停止线程 */ public class TestThreadDemo01 implements Runnable{ public static void main(String[] args) throws Exception { ...
  • quartz执行卡死--强制中断线程

    千次阅读 2017-03-08 11:48:10
    而有时候一时无法定位到卡死的原因,为了降低系统风险,我们就会希望有一个超时机制,当执行超时时强制中断该操作。下面就举个例子,ftp协议不稳定,当连接ftp上传下载数据时有时候会遇到不可知的因素会导致卡死,...
  • JAVA 超时中断处理

    2021-03-05 13:57:33
    或者调用某一接口执行的时间过长),导致程序长时间卡死,因此,需要对程序进行超时中断处理,给程序的执行时间设定一个时间范围限制,如果超过这一范围,则进行中断处理,包括中断线程并且返回超时的结果。...
  • void interrupt():中断线程,例如线程A运行时,线程B可以调用线程A的interrupt方法来设置线程A的中断标志位true。注意:这里仅仅是设置了标志,线程A并没有中断,它会继续往下执行。如果线程A调用了wait系列函数,...
  • 读《Java核心技术 卷一》记录。 当线程得 run 方法执行方法体中最后一条语句后,并经由执行 return...当对一个线程调用 interrupt 方法时,线程中断状态将被置位。这是每个线程都具有的 Boolean 标志。每个线程都应.
  • 一只甜甜圈如果你暴露线程执行程序让你运行,那么你可以打断它。...如果你没有检查Thread.isInterrupted(就像他们两个那样),你仍然可能无法中断线程。ExecutorServiceexecutor=Executors.newSingleThrea...
  • java线程-02-线程中断 interrupt()

    万次阅读 2021-06-11 09:34:03
    线程的Thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,完全取决于目标线程的自行决定。线程会不时地检测这个中断标志...
  • Java 停止线程的方式Java中有常见的停止线程的方式:使用interrupt()方法中断线程使用退出标记来停止线程使用stop()方法停止线程 Java中有常见的停止线程的方式: 使用interrupt()方法中断线程 我们可以使用thread....
  • java创建线程的几种方式 1、实现Runnable接口。 public class RunnableDemo implements Runnable{ public static void main(String[] args) { //写法1 new Thread(new RunnableDemo(), "runnable线程1").start();...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,559
精华内容 15,423
关键字:

java强制中断线程

java 订阅