精华内容
下载资源
问答
  • 线程中断的几种方式
    千次阅读
    2021-08-10 14:51:47

    有三种方法可以使终止线程。

    1.  使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。
    
    2.  使用stop方法强行终止线程(这个方法不推荐使用,因为stop和suspend、resume一样,也可能发生不可预料的结果)。
    
    3.  使用interrupt方法中断线程。
    
    • 1.使用退出标识终止线程
      当run方法执行完后,线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求,或是其他的需要循环处理的任务。在这种情况下,一般是将这些任务放在一个循环中,如while循环。如果想让循环永远运行下去,可以使用while(true){……}来处理。但要想使while循环在某一特定条件下退出,最直接的方法就是设一个boolean类型的标志,并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。
    package chapter2;
     
    public class ThreadFlag extends Thread
    {
        public volatile boolean exit = false;
     
        public void run()
        {
            while (!exit);
        }
        public static void main(String[] args) throws Exception
        {
            ThreadFlag thread = new ThreadFlag();
            thread.start();
            sleep(5000); // 主线程延迟5秒
            thread.exit = true;  // 终止线程thread
            thread.join();
            System.out.println("线程退出!");
        }
    }
    

    在上面代码中定义了一个退出标志exit,当exit为true时,while循环退出,exit的默认值为false.在定义exit时,使用了一个Java关键字volatile,这个关键字的目的是使exit同步,也就是说在同一时刻只能由一个线程来修改exit的值

      1. 使用stop方法终止线程

      使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程:

       thread.stop();
    

    虽然使用上面的代码可以终止线程,但使用stop方法是很危险的,就象突然关闭计算机电源,而不是按正常程序关机一样,可能会产生不可预料的结果,因此,并不推荐使用stop方法来终止线程。

      1. 使用interrupt方法终止线程
    使用interrupt方法来终端线程可分为两种情况:
    
    (1)线程处于阻塞状态,如使用了sleep方法。
    
    (2)使用while(!isInterrupted()){……}来判断线程是否被中断。
    

    在第一种情况下使用interrupt方法,sleep方法将抛出一个InterruptedException例外,而在第二种情况下线程将直接退出。下面的代码演示了在第一种情况下使用interrupt方法。

    package chapter2;
     
    public class ThreadInterrupt extends Thread
    {
        public void run()
        {
            try
            {
                sleep(50000);  // 延迟50秒
            }
            catch (InterruptedException e)
            {
                System.out.println(e.getMessage());
            }
        }
        public static void main(String[] args) throws Exception
        {
            Thread thread = new ThreadInterrupt();
            thread.start();
            System.out.println("在50秒之内按任意键中断线程!");
            System.in.read();
            thread.interrupt();
            thread.join();
            System.out.println("线程已经退出!");
        }
    }
    

    上面代码的运行结果如下:

    50秒之内按任意键中断线程!
     
        sleep interrupted
        线程已经退出! 
    

    在调用interrupt方法后, sleep方法抛出异常,然后输出错误信息:sleep interrupted.

    注意:在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个是静态的方法interrupted(),一个是非静态的方法isInterrupted(),这两个方法的区别是interrupted用来判断当前线是否被中断,而isInterrupted可以用来判断其他线程是否被中断。因此,while (!isInterrupted())也可以换成while (!Thread.interrupted())。

    更多相关内容
  • Java的中断是一种协作机制。也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程,它只是要求线程自己在合适的时机中断自己,本文将详细介绍,需要了解的朋友可以参考下
  • 线程中断   Java 中的线程中断是一种线程间的协作模式,通过设置线程的中断标志并不能直接终止该线程的执行,而是被中断的线程根据中断状态自行处理。即“线程中断”并不是字面意思——线程真的中断了,而是设置了...
  • 主要介绍了Java检测线程中断状态的方法,结合实例形式分析了java针对线程中断状态检测的相关实现技巧,需要的朋友可以参考下
  • 什么是线程中断?   在我们的Java程序中其实有不止一条执行线程,只有当所有的线程都运行结束的时候,这个Java程序才算运行结束。 官方的话给你描述一下:当所有的非守护线程运行结束时,或者其中一个线程调用了...

    什么是线程中断?

     

    在我们的Java程序中其实有不止一条执行线程,只有当所有的线程都运行结束的时候,这个Java程序才算运行结束。

    官方的话给你描述一下:当所有的非守护线程运行结束时,或者其中一个线程调用了System.exit()方法时,这个Java程序才能运行结束。

     

    线程中断的应用场景

     

    我们先来举一个例子,比如我们现在在下载一个500多M的大片,我们点击开始下载,那个这个时候就等于开启了一个线程去下载我们的文件,然而这个时候我们的网速不是很给力,几十KB的在这跑,作为一个年轻人我是等不了了,我不下来,那么这个时候我们第一个操作就是结束掉这个下载文件的操作,其实更接近程序的来说,这个时候我们就需要把这个线程给中断了。

     

     

    我们接下来写一下这个下载的代码,看一下如何中断一个线程,这里我已经默认你们已经掌握了如何创建一个线程了,这段程序我们模拟下载,最开始获取系统时间,然后进入循环每次获取系统时间,如果时间超过10秒我们就中断线程,不在继续下载,下载速度时每秒1M:

    public void run() {
    
           int number = 0;
    
           // 记录程序开始的时间
           Long start = System.currentTimeMillis();
    
           while (true) {
    
               // 每次执行一次结束的时间
               Long end = System.currentTimeMillis();
    
               // 获取时间差
               Long interval = end - start;
    
               // 如果时间超过了10秒,那么我们就结束下载
               if (interval >= 10000) {
                   // 中断线程
                   interrupted();
                   System.err.println("太慢了,我不下了");
                   return;
               } else if (number >= 500) {
                   System.out.println("文件下载完成");
                   // 中断线程
                   interrupted();
                   return;
               }
    
               number++;
               System.out.println("已下载" + number + "M");
    
               try {
                   Thread.sleep(2000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }

     

    中断线程的方式

     

    Thread类中给我们提供了中断线程的方法,我们先来看下这个方法到底是如何让线程中断的:

    public static boolean interrupted() {
           return currentThread().isInterrupted(true);
       }

     

    这个方法是检查当前线程是否被中断,中断返回true,未中断返回false

    private native boolean isInterrupted(boolean ClearInterrupted);

     

    通过查看源码我们可以发现,中断线程就是通过调用检查线程是否被中断的方法,把值设为true。这个时候你再去调用检查线程是否中断的方法时就返回true了。

     

    这里大家需要注意一个问题:Thread.interrupted()方法只是修改了当前线程的状态告诉他被中断了,但是对于非阻塞中的线程,只是改变了中断状态,即

    Thread.isInterrupted()返回true,对于可取消的阻塞状态中的线程,例如等待在这些函数上的线程 ,Thread.sleep(),这个线程收到中断信号之后就会抛出InterruptedException异常,同时会把中断状态设置为true。

     

    线程睡眠引起InterruptedException异常的原因

     

    其实这样说大家也是一知半解,我就写一个错误的示例,大家来看一下,把这个问题彻底的搞清楚:

    public void run() {
    
           int number = 0;
    
           while (true) {
               // 检查线程是否被中断,中断就停止下载
               if (isInterrupted()) {
    
                   System.err.println("太慢了,我不下了");
                   return;
               } else if (number >= 500) {
                   System.out.println("下载完成");
                   return;
               }
    
               number++;
               System.out.println("已下载" + number + "M");
    
               try {
                   Thread.sleep(2000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }

     

     

    这是我们的主程序,等待10秒后中断线程

    public static void main(String[] args) throws InterruptedException {
    
           Thread thread = new PrimeGenerator();
    
           // 启动线程
           thread.start();
    
           // 等待10秒后中断线程
           Thread.sleep(1000);
    
           // 中断线程
           thread.interrupt();
       }

     

    看起来很通常的一个程序,但是事实却并非你看到的样子,其实这段代码是会抛出InterruptedException异常的,我们来分析原因。

     

     

    这里我们先要了解Thread.interrupt()方法不会中断一个正在运行的线程,调用Thread.sleep()方法时,这个时候就不再占用CPU,我们来分析下我们这个程序,我们下载是要等待10秒,每次下载的速度是0.5M/S,也就是当我们下载到5M的时候等待时间已经到了,这个时候调用Thread.interrupt()方法中断线程,但是run()方法中的睡眠还要接着往下执行,它是不会因为中断而放弃执行下面的代码的,那么这个时候当它再执行Thread.sleep()的时候就会抛出InterruptedException异常,因为当前的线程已经被中断了。

     

    说到这里,你是否已经明白产生这个异常的原因了?另外还有另外的两个原因致使线程产生InterruptedException异常的原因,wait()、join()两个方法使用不当也会引起线程抛出该异常。

     

    查看线程是否中断的两种方式

     

    在Thread类中有一个方法interrupted()可以用来检查当前线程时候被中断,还有isInterrupted()方法可以用来检查当前线程是否被中断。

     

    中断线程的方法其实底层就是将这个属性设置为true,isInterrupted()方法只是返回了这个属性值而已。

     

    这两个方法有一个区别就是isInterrupted()不能改变interrupted()的属性值,但是interrupted()方法却能改变interrupted的属性值,所以在判断一个线程时候被中断的时候我们更推荐使用isInterrupted()。

    本文转自:https://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247486309&idx=2&sn=1fe46ec0d5468b855c3a4af82d3996f1&chksm=ebd63449dca1bd5f3f0be5a72f2e565f85e615f26899e5a08889bc7d1c53a2dbb81b35597b68&mpshare=1&scene=1&srcid=0909cibXdy1CwbiK5EVKStJS#rd

    展开全文
  • C++11关于thead的应用,利用std::condition std::mutex提供如何中断,停止和继续功能,
  • 线程中断到底是什么

    千次阅读 2020-03-27 09:28:41
    我们如何让线程安全的停止呢? 1. 线程自然终止 自然执行完或抛出未处理异常。 2. stop(),resume(),suspend()方法 stop(),resume(),suspend()已不建议使用,stop()会导致线程不会正确释放资源,suspend()容易导致...

    提示:更多优秀博文请移步博主的GitHub仓库:GitHub学习笔记Gitee学习笔记

    我们如何让线程安全的停止呢?

    1. 线程自然终止

    自然执行完或抛出未处理异常。

    2. stop(),resume(),suspend()方法

    stop(),resume(),suspend()已不建议使用,stop()会导致线程不会正确释放资源,suspend()容易导致死锁。

    • 停止多线程: public void stop();
    • 销毁多线程: public void destory();
    • 挂起线程: public final void suspend(); 暂停执行
    • 恢复挂起的线程执行: public final void resume();

    3. 线程中断

    Thread类提供了interrupt方法,用于中断目标线程的执行。

    3.1 interrupt方法

    interrupt()方法用于中断一个线程,而Java中线程的处理是协作式的而不是抢占式的。所谓协作式的意思是:实际上调用一个线程的interrupt() 方法中断一个线程,并不是强行关闭这个线程,只是跟这个线程打个招呼,将线程的中断标志位置为true,线程是否中断,由线程本身决定。

    public class UserRunnable implements Runnable {
        @Override
        public void run() {
            while (true){
                System.out.println(Thread.currentThread().getName()+"is running");
            }
        }
    }
    
    public class SafeExitTest {
        public static void main(String[] args) {
            Thread thread = new Thread(new UserRunnable());
            thread.start();
            thread.interrupt();
        }
    }
    

    我们可以看到,在UserRunnable线程中,我们并没有对中断进行任何处理,所以在SafeExitTest中调用线程的interrupt方法并不会导致线程的中断,控制台还是会继续打印。只有在目标线程中进行了正确的中断处理后才会有中断效果:

    public class UserRunnable implements Runnable {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {//判断当前线程是否被中断
                System.out.println(Thread.currentThread().getName() + "is running");
            }
        }
    }
    

    Thread类中相关方法

    • isInterrupted() :判定指定线程是否处于中断状态。
    • static interrupted() :静态方法,判定当前线程是否处于中断状态,同时将中断标志位改为false。

    3.2 阻塞线程与线程中断

    Java中断响应是描述当一个线程或方法A处于运行、阻塞或死锁状态时,外界(通常指其他线程、系统IO等)对A的影响能否让A线程或者方法抛出InterruptedException异常并提前返回,如果会提前返回并且抛出InterruptedException,就叫可中断响应方法或线程,如果不会抛出InterruptedException,就叫不可中断线程或方法。

    Java语言中所有阻塞方法都声明抛出InterruptedException异常(例如 Thread.sleep()Thread.join()Object.wait())。也就是说,如果一个线程执行了阻塞方法,使得当前线阻塞,第三方线程执行interrupt方法中断线程,都会使得该阻塞方法抛出InterruptedException异常并退出阻塞,并且将当前线程的中断标志位设置为false

    如果没有这个机制, interrupt() 则只是单纯设置线程的中断状态。那这个试图中断的线程仍在阻塞当中,那么后序的中断工作则无法进行。

    3.3 阻塞线程的线程中断案例

    public class UserRunnable implements Runnable {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "is running");
                try {
                    Thread.sleep(10);//第7行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public class SafeExitTest {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new UserRunnable());
            thread.start();
            Thread.sleep(10);
            thread.interrupt();//第6行
        }
    }
    

    上面的代码我们仅仅是在每次循环的时候让线程sleep了10ms,但这很有可能会导致中断操作的失败(注意这里说的是很有可能)。

    在这里插入图片描述

    可以看到控制台不断输出"Thread-0is running",这是因为在执行SafeExitTest:6(SafeExitTest类的第6行代码)这行代码时,目标线程处于阻塞状态,此时UserRunnable:7这行代码抛出InterruptedException异常,线程退出阻塞状态,并将中断标志位设置为false。这也就是为什么虽然在while语句中对中断标志位进行了判断,而在主线程试图中断目标线程时,目标线程仍能继续循环的原因。

    经过多次测试也会出现中断成功的情况:

    在这里插入图片描述

    出现这种情况,是因为中断操作放生在第一次循环完成和第二次循环判断开始之前。

    具体细节参考

    https://blog.csdn.net/meiliangdeng1990/article/details/80559012

    https://www.ibm.com/developerworks/cn/java/j-jtp05236.html

    展开全文
  • 线程中断详解

    万次阅读 多人点赞 2018-07-05 19:01:44
    中断线程线程的thread.interrupt()方法是中断线程,将会设置该线程中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示...

    中断线程

    线程的thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示位,以判断线程是否应该被中断(中断标示值是否为true)。它并不像stop方法那样会中断一个正在运行的线程。

    判断线程是否被中断

    判断某个线程是否已被发送过中断请求,请使用Thread.currentThread().isInterrupted()方法(因为它将线程中断标示位设置为true后,不会立刻清除中断标示位,即不会将中断标设置为false),而不要使用thread.interrupted()(该方法调用后会将中断标示位清除,即重新设置为false)方法来判断,下面是线程在循环中时的中断方式:

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

    如何中断线程

    如果一个线程处于了阻塞状态(如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态),则在线程在检查中断标示时如果发现中断标示为true,则会在这些阻塞方法(sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法)调用处抛出InterruptedException异常,并且在抛出异常后立即将线程的中断标示位清除,即重新设置为false。抛出异常是为了线程从阻塞状态醒过来,并在结束线程前让程序员有足够的时间来处理中断请求。

     

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

     

    没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断。某些线程非常重要,以至于它们应该不理会中断,而是在处理完抛出的异常之后继续执行,但是更普遍的情况是,一个线程将把中断看作一个终止请求,这种线程的run方法遵循如下形式:

    public void run() {
        try {
            ...
            /*
             * 不管循环里是否调用过线程阻塞的方法如sleep、join、wait,这里还是需要加上
             * !Thread.currentThread().isInterrupted()条件,虽然抛出异常后退出了循环,显
             * 得用阻塞的情况下是多余的,但如果调用了阻塞方法但没有阻塞时,这样会更安全、更及时。
             */
            while (!Thread.currentThread().isInterrupted()&& more work to do) {
                do more work 
            }
        } catch (InterruptedException e) {
            //线程在wait或sleep期间被中断了
        } finally {
            //线程结束前做一些清理工作
        }
    }

    上面是while循环在try块里,如果try在while循环里时,因该在catch块里重新设置一下中断标示,因为抛出InterruptedException异常后,中断标示位会自动清除,此时应该这样:

    public void run() {
        while (!Thread.currentThread().isInterrupted()&& more work to do) {
            try {
                ...
                sleep(delay);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();//重新设置中断标示
            }
        }
    }

    底层中断异常处理方式

    另外不要在你的底层代码里捕获InterruptedException异常后不处理,会处理不当,如下:

    void mySubTask(){
        ...
        try{
            sleep(delay);
        }catch(InterruptedException e){}//不要这样做
        ...
    }

    如果你不知道抛InterruptedException异常后如何处理,那么你有如下好的建议处理方式:
    1、在catch子句中,调用Thread.currentThread.interrupt()来设置中断状态(因为抛出异常后中断标示会被清除),让外界通过判断Thread.currentThread().isInterrupted()标示来决定是否终止线程还是继续下去,应该这样做:

    void mySubTask() {
        ...
        try {
            sleep(delay);
        } catch (InterruptedException e) {
            Thread.currentThread().isInterrupted();
        }
        ...
    }

    2、或者,更好的做法就是,不使用try来捕获这样的异常,让方法直接抛出:

    void mySubTask() throws InterruptedException {
        ...
        sleep(delay);
        ...
    }

    中断应用

    使用中断信号量中断非阻塞状态的线程

    中断线程最好的,最受推荐的方式是,使用共享变量(shared variable)发出信号,告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量,然后有秩序地中止任务。Example2描述了这一方式:

    class Example2 extends Thread {
        volatile boolean stop = false;// 线程中断信号量
    
        public static void main(String args[]) throws Exception {
            Example2 thread = new Example2();
            System.out.println("Starting thread...");
            thread.start();
            Thread.sleep(3000);
            System.out.println("Asking thread to stop...");
            // 设置中断信号量
            thread.stop = true;
            Thread.sleep(3000);
            System.out.println("Stopping application...");
        }
    
        public void run() {
            // 每隔一秒检测一下中断信号量
            while (!stop) {
                System.out.println("Thread is running...");
                long time = System.currentTimeMillis();
                /*
                 * 使用while循环模拟 sleep 方法,这里不要使用sleep,否则在阻塞时会 抛
                 * InterruptedException异常而退出循环,这样while检测stop条件就不会执行,
                 * 失去了意义。
                 */
                while ((System.currentTimeMillis() - time < 1000)) {}
            }
            System.out.println("Thread exiting under request...");
        }
    }

    使用thread.interrupt()中断非阻塞状态线程

    虽然Example2该方法要求一些编码,但并不难实现。同时,它给予线程机会进行必要的清理工作。这里需注意一点的是需将共享变量定义成volatile 类型或将对它的一切访问封入同步的块/方法(synchronized blocks/methods)中。上面是中断一个非阻塞状态的线程的常见做法,但对非检测isInterrupted()条件会更简洁:

    class Example2 extends Thread {
        public static void main(String args[]) throws Exception {
            Example2 thread = new Example2();
            System.out.println("Starting thread...");
            thread.start();
            Thread.sleep(3000);
            System.out.println("Asking thread to stop...");
            // 发出中断请求
            thread.interrupt();
            Thread.sleep(3000);
            System.out.println("Stopping application...");
        }
    
        public void run() {
            // 每隔一秒检测是否设置了中断标示
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");
                long time = System.currentTimeMillis();
                // 使用while循环模拟 sleep
                while ((System.currentTimeMillis() - time < 1000) ) {
                }
            }
            System.out.println("Thread exiting under request...");
        }
    }

    到目前为止一切顺利!但是,当线程等待某些事件发生而被阻塞,又会发生什么?当然,如果线程被阻塞,它便不能核查共享变量,也就不能停止。这在许多情况下会发生,例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时,这里仅举出一些。

    他们都可能永久的阻塞线程。即使发生超时,在超时期满之前持续等待也是不可行和不适当的,所以,要使用某种机制使得线程更早地退出被阻塞的状态。下面就来看一下中断阻塞线程技术。

    使用thread.interrupt()中断阻塞状态线程

    Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是,设置线程的中断标示位,在线程受到阻塞的地方(如调用sleep、wait、join等地方)抛出一个异常InterruptedException,并且中断状态也将被清除,这样线程就得以退出阻塞的状态。下面是具体实现:

    class Example3 extends Thread {
        public static void main(String args[]) throws Exception {
            Example3 thread = new Example3();
            System.out.println("Starting thread...");
            thread.start();
            Thread.sleep(3000);
            System.out.println("Asking thread to stop...");
            thread.interrupt();// 等中断信号量设置后再调用
            Thread.sleep(3000);
            System.out.println("Stopping application...");
        }
    
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread running...");
                try {
                    /*
                     * 如果线程阻塞,将不会去检查中断信号量stop变量,所 以thread.interrupt()
                     * 会使阻塞线程从阻塞的地方抛出异常,让阻塞线程从阻塞状态逃离出来,并
                     * 进行异常块进行 相应的处理
                     */
                    Thread.sleep(1000);// 线程阻塞,如果线程收到中断操作信号将抛出异常
                } catch (InterruptedException e) {
                    System.out.println("Thread interrupted...");
                    /*
                     * 如果线程在调用 Object.wait()方法,或者该类的 join() 、sleep()方法
                     * 过程中受阻,则其中断状态将被清除
                     */
                    System.out.println(this.isInterrupted());// false
    
                    //中不中断由自己决定,如果需要真真中断线程,则需要重新设置中断位,如果
                    //不需要,则不用调用
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Thread exiting under request...");
        }
    }

    一旦Example3中的Thread.interrupt()被调用,线程便收到一个异常,于是逃离了阻塞状态并确定应该停止。上面我们还可以使用共享信号量来替换!Thread.currentThread().isInterrupted()条件,但不如它简洁。

    死锁状态线程无法被中断

    Example4试着去中断处于死锁状态的两个线程,但这两个线都没有收到任何中断信号(抛出异常),所以interrupt()方法是不能中断死锁线程的,因为锁定的位置根本无法抛出异常:

    class Example4 extends Thread {
        public static void main(String args[]) throws Exception {
            final Object lock1 = new Object();
            final Object lock2 = new Object();
            Thread thread1 = new Thread() {
                public void run() {
                    deathLock(lock1, lock2);
                }
            };
            Thread thread2 = new Thread() {
                public void run() {
                    // 注意,这里在交换了一下位置
                    deathLock(lock2, lock1);
                }
            };
            System.out.println("Starting thread...");
            thread1.start();
            thread2.start();
            Thread.sleep(3000);
            System.out.println("Interrupting thread...");
            thread1.interrupt();
            thread2.interrupt();
            Thread.sleep(3000);
            System.out.println("Stopping application...");
        }
    
        static void deathLock(Object lock1, Object lock2) {
            try {
                synchronized (lock1) {
                    Thread.sleep(10);// 不会在这里死掉
                    synchronized (lock2) {// 会锁在这里,虽然阻塞了,但不会抛异常
                        System.out.println(Thread.currentThread());
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }

    中断I/O操作

    然而,如果线程在I/O操作进行时被阻塞,又会如何?I/O操作可以阻塞线程一段相当长的时间,特别是牵扯到网络应用时。例如,服务器可能需要等待一个请求(request),又或者,一个网络应用程序可能要等待远端主机的响应。

     

    实现此InterruptibleChannel接口的通道是可中断的:如果某个线程在可中断通道上因调用某个阻塞的 I/O 操作(常见的操作一般有这些:serverSocketChannel. accept()、socketChannel.connect、socketChannel.open、socketChannel.read、socketChannel.write、fileChannel.read、fileChannel.write)而进入阻塞状态,而另一个线程又调用了该阻塞线程的 interrupt 方法,这将导致该通道被关闭,并且已阻塞线程接将会收到ClosedByInterruptException,并且设置已阻塞线程的中断状态。另外,如果已设置某个线程的中断状态并且它在通道上调用某个阻塞的 I/O 操作,则该通道将关闭并且该线程立即接收到 ClosedByInterruptException;并仍然设置其中断状态。如果情况是这样,其代码的逻辑和第三个例子中的是一样的,只是异常不同而已。

     

    如果你正使用通道(channels)(这是在Java 1.4中引入的新的I/O API),那么被阻塞的线程将收到一个ClosedByInterruptException异常。但是,你可能正使用Java1.0之前就存在的传统的I/O,而且要求更多的工作。既然这样,Thread.interrupt()将不起作用,因为线程将不会退出被阻塞状态。Example5描述了这一行为。尽管interrupt()被调用,线程也不会退出被阻塞状态,比如ServerSocket的accept方法根本不抛出异常。

     

    很幸运,Java平台为这种情形提供了一项解决方案,即调用阻塞该线程的套接字的close()方法。在这种情形下,如果线程被I/O操作阻塞,当调用该套接字的close方法时,该线程在调用accept地方法将接收到一个SocketException(SocketException为IOException的子异常)异常,这与使用interrupt()方法引起一个InterruptedException异常被抛出非常相似,(注,如果是流因读写阻塞后,调用流的close方法也会被阻塞,根本不能调用,更不会抛IOExcepiton,此种情况下怎样中断?我想可以转换为通道来操作流可以解决,比如文件通道)。下面是具体实现:

    class Example6 extends Thread {
        volatile ServerSocket socket;
    
        public static void main(String args[]) throws Exception {
            Example6 thread = new Example6();
            System.out.println("Starting thread...");
            thread.start();
            Thread.sleep(3000);
            System.out.println("Asking thread to stop...");
            Thread.currentThread().interrupt();// 再调用interrupt方法
            thread.socket.close();// 再调用close方法
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
            }
            System.out.println("Stopping application...");
        }
    
        public void run() {
            try {
                socket = new ServerSocket(8888);
            } catch (IOException e) {
                System.out.println("Could not create the socket...");
                return;
            }
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Waiting for connection...");
                try {
                    socket.accept();
                } catch (IOException e) {
                    System.out.println("accept() failed or interrupted...");
                    Thread.currentThread().interrupt();//重新设置中断标示位
                }
            }
            System.out.println("Thread exiting under request...");
        }
    }

    一、没有任何语言方面的需求一个被中断的线程应该终止。中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断。

    二、对于处于sleep,join等操作的线程,如果被调用interrupt()后,会抛出InterruptedException,然后线程的中断标志位会由true重置为false,因为线程为了处理异常已经重新处于就绪状态。

    三、不可中断的操作,包括进入synchronized段以及Lock.lock(),inputSteam.read()等,调用interrupt()对于这几个问题无效,因为它们都不抛出中断异常。如果拿不到资源,它们会无限期阻塞下去。

    对于Lock.lock(),可以改用Lock.lockInterruptibly(),可被中断的加锁操作,它可以抛出中断异常。等同于等待时间无限长的Lock.tryLock(long time, TimeUnit unit)。

    对于inputStream等资源,有些(实现了interruptibleChannel接口)可以通过close()方法将资源关闭,对应的阻塞也会被放开。

     

    首先,看看Thread类里的几个方法:

    public static boolean interrupted测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说,如果连续两次调用该方法,则第二次调用将返回 false。

    public boolean isInterrupted()

    测试线程是否已经中断。线程的中断状态 不受该方法的影响。

    public void interrupt()

    中断线程。

    上面列出了与中断有关的几个方法及其行为,可以看到interrupt是中断线程。如果不了解Java的中断机制,这样的一种解释极容易造成误解,认为调用了线程的interrupt方法就一定会中断线程。

    其实,Java的中断是一种协作机制。也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程,它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态(这个状态不在Thread的属性上),interrupt方法仅仅只是将该状态置为true。

    比如对正常运行的线程调用interrupt()并不能终止他,只是改变了interrupt标示符。

    一般说来,如果一个方法声明抛出InterruptedException,表示该方法是可中断的,比如wait,sleep,join,也就是说可中断方法会对interrupt调用做出响应(例如sleep响应interrupt的操作包括清除中断状态,抛出InterruptedException),异常都是由可中断方法自己抛出来的,并不是直接由interrupt方法直接引起的。

    Object.wait, Thread.sleep方法,会不断的轮询监听 interrupted 标志位,发现其设置为true后,会停止阻塞并抛出 InterruptedException异常。

    --------------------------------------------------------------------------------------------------------------------------------------------------------------

    看了以上的说明,对java中断的使用肯定是会了,但我想知道的是阻塞了的线程是如何通过interuppt方法完成停止阻塞并抛出interruptedException的,这就要看Thread中native的interuppt0方法了。

    第一步学习Java的JNI调用Native方法。

     

    第二步下载openjdk的源代码,找到目录结构里的openjdk-src\jdk\src\share\native\java\lang\Thread.c文件。

    #include "jni.h"
    #include "jvm.h"
    
    #include "java_lang_Thread.h"
    
    #define THD "Ljava/lang/Thread;"
    #define OBJ "Ljava/lang/Object;"
    #define STE "Ljava/lang/StackTraceElement;"
    
    #define ARRAY_LENGTH(a) (sizeof(a)/sizeof(a[0]))
    
    static JNINativeMethod methods[] = {
        {"start0",           "()V",        (void *)&JVM_StartThread},
        {"stop0",            "(" OBJ ")V", (void *)&JVM_StopThread},
        {"isAlive",          "()Z",        (void *)&JVM_IsThreadAlive},
        {"suspend0",         "()V",        (void *)&JVM_SuspendThread},
        {"resume0",          "()V",        (void *)&JVM_ResumeThread},
        {"setPriority0",     "(I)V",       (void *)&JVM_SetThreadPriority},
        {"yield",            "()V",        (void *)&JVM_Yield},
        {"sleep",            "(J)V",       (void *)&JVM_Sleep},
        {"currentThread",    "()" THD,     (void *)&JVM_CurrentThread},
        {"countStackFrames", "()I",        (void *)&JVM_CountStackFrames},
        {"interrupt0",       "()V",        (void *)&JVM_Interrupt},
        {"isInterrupted",    "(Z)Z",       (void *)&JVM_IsInterrupted},
        {"holdsLock",        "(" OBJ ")Z", (void *)&JVM_HoldsLock},
        {"getThreads",        "()[" THD,   (void *)&JVM_GetAllThreads},
        {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
    };
    
    #undef THD
    #undef OBJ
    #undef STE
    
    JNIEXPORT void JNICALL
    Java_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)
    {
        (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
    }


    展开全文
  • 中断线程相关的方法 中断线程有一些相应的方法,这里列出来一下。 注意,如果是Thread.method(),则代表是静态方法。如果是thread.method()则代表着是类方法 void thread.stop() 这个方法能中断正在运行的线程,...
  • Java中的线程中断

    2020-09-11 17:25:40
    1.三个方法: interrupt() ...只会返回线程中断状态,不会修改标志位。 interrupted() 返回当前线程的中断状态,然后会将线程的中断状态清除,也就是将标志位设置为false。 2.停止线程的三种方法 https://
  • 线程中断机制

    2018-08-21 23:04:42
    之前我们捋清楚了线程中的sleep(),wait(),join()等方法,这里我们再来学习下java中的线程中断机制。中断是一种协作机制。当一个线程中断另一个线程时,被中断的线程不一定要立即停止正在做的事情。相反,中断是礼貌...
  • 最近在学习JUC框架的时候,发现了很多工具类都是支持可中断的,如AQS、FutureTask都是可以在线程执行中,支持对于中断的响应,所以需要对线程中断有个了解,才能更好的学习JUC的源码。 线程中断的作用: 线程中断...
  • 主要介绍了java多线程中断代码详解,具有一定参考价值,需要的朋友可以了解下。
  • 线程中断 常见的有以下两种方式: 通过共享的标记来进行沟通 调用 interrupt() 方法来通知 通过共享的标记来实现中断 就是创建一个boolean类型的变量来控制循环是否进行,就是一个标记。 代码如下: /** * 描述:...
  • 主要介绍了Java并发编程示例(三):线程中断,在本节,我们所开发的示例程序将会创建一个线程,五秒钟后,利用中断机制强制中止这个线程,需要的朋友可以参考下
  • 主要介绍了Android中断线程的处理方法,涉及到线程中断、处理与返回等操作,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 本篇主要来学习下Java中对线程中断机制的实现。在我们的程序中经常会有一些不达到目的不会退出的线程,例如:我们有一个下载程序线程,该线程在没有下载成功之前是不会退出的,若此时用户觉得下载速度慢,不想下载了...
  • 主要介绍了Java多线程中断机制三种方法及示例,向大家分享了这三种方法的介绍几代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 线程中断的方式(interrupt详解)

    千次阅读 2020-04-23 00:57:03
    1.线程中断的方式总结? 1.正常退出:在线程start()开启之后,当线程执行完run()或call()方法之后,此时,该线程会正常退出。 2.stop强制退出:在Thread类中,可以发现其中的stop()方法上加有@Deprecated注解,表示...
  • 主要介绍了Java并发编程示例(四):可控的线程中断,在本节,我们将使用一个线程查找指定目录及其子目录下文件来演示通过使用InterruptedException异常控制线程中断,需要的朋友可以参考下
  • AQS独占锁取消排队与线程中断

    千次阅读 2019-01-16 11:53:00
    大家推荐个靠谱的公众号程序员探索之路,公众号内点击网赚获取彩蛋,... //这个方法是 自旋获取锁/获取不到锁线程挂起等待唤醒 final boolean acquireQueued(final Node node, int arg) { boolean failed = true; ...
  • 1.概述基本实现是,通过 InterruptedException 异常来终止程序,至于线程什么时候终止,只能由jvm来决定了,若理解的不到位,欢迎大牛们指点2.code 如下package com.qimh.springbootfiledemo.Thread;import ...
  • Qt 线程中断(终止,退出)

    千次阅读 2021-08-08 13:18:36
    场景: 有的时候我们开线程做耗时的任务, 但很久了也没有完成, 我可能会有会暂停线程(或者中止) Worker = make_shared<WorkerRandom>() Thread.start(); Worker->moveToThread(&Thread); connect...
  • 主要介绍了JAVA多线程中断机制stop()、interrupted()、isInterrupted()的相关资料,需要的朋友可以参考下
  • JAVA线程中断Interrupt恢复办法

    千次阅读 2020-05-28 18:39:21
    最近学习了线程中断原理,由于线程在运行中,如果执行了sleep方法,会被trycatch捕获到,然后会出现中断方法的上层方法捕获不到,于是研究了下,发现下层方法里,中断后,被异常捕获,捕获后把线程中断信号清除了,做此文用来...
  • 线程中断机制

    万次阅读 多人点赞 2017-08-18 12:02:55
    在 java中启动线程非常容易,大多数情况下是让一个线程执行完自己的任务然后自己停掉... 在当前的api中,Thread.suspend、Thread.stop等方法都被Deprecated了,线程只能用interrupt中断,而且不是立刻中断,只是发了一
  • c++并发编程(七)—— 线程中断

    千次阅读 2019-02-26 10:52:14
    这里我们首先看看一个简单的思路:要想从一个线程终止另外一个线程,我们可以设置一个flag,这两个线程均可以访问的到,于是需要被中断线程只需要检测这个flag的状态是否被改变,并由此作出是否中断的决定。...
  • 最近在系统回顾多线程这一部分的内容,对线程中断方式这一部分相比之前有了不同的认识。整理一下,如有理解偏颇之处,还请各位大神不惜赐教。 在看高洪岩《Java多线程编程核心技术》的时候里面讲了很多种停止线程...
  • Java挑战高并发(2):线程中断

    千次阅读 2016-07-24 01:03:25
    当一个线程运行时,另一个线程可以调用对应的Thread对象的interrupt()方法来中断它,该方法只是在目标线程中设置一个标志,表示它已经被中断,并立即返回。这里需要注意的是,如果只是单纯的调用interrupt()方法...
  • java 线程 中断标志位

    千次阅读 2018-05-19 12:19:00
    课程素材来自 http://enjoy.ke.qq.com/ 版权所有java线程中,线程中断方法详解:线程自然终止:自然执行完或抛出未处理异常stop(),resume(),suspend()已不建议使用,stop()会导致线程不会正确释放资源,suspend()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 326,055
精华内容 130,422
关键字:

线程中断