精华内容
下载资源
问答
  • 什么是线程中断?   在我们的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

    展开全文
  • 什么是线程中断? 在我们的Java程序中其实有不止一条执行线程,只有当所有的线程都运行结束的时候,这个Java程序才算运行结束。 官方的话给你描述一下:当所有的非守护线程运行结束时,或者其中一个线程调用了System...

    什么是线程中断?

    在我们的Java程序中其实有不止一条执行线程,只有当所有的线程都运行结束的时候,这个Java程序才算运行结束。 官方的话给你描述一下:当所有的非守护线程运行结束时,或者其中一个线程调用了System.exit()方法时,这个Java程序才能运行结束。

    线程中断的应用场景

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

    我们接下来写一下这个下载的代码,看一下如何中断一个线程,这里我已经默认你们已经掌握了如何创建一个线程了,这段程序我们模拟下载,最开始获取系统时间,然后进入循环每次获取系统时间,如果时间超过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异常的,我们来分析原因。

    _2

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

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

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

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

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

    _3

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

    文章来源:https://my.oschina.net/u/3178270/blog/2045625

    推荐阅读:https://www.roncoo.com/article/index?title=%E7%BA%BF%E7%A8%8B

    展开全文
  • 线程中断详解

    万次阅读 多人点赞 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));
    }


    展开全文
  • Java线程中断的理解和正确使用 1、为什么废弃Thread的stop函数? 对于有多线程开发经验的开发者,应该大多数在开发过程中都遇到过这样的需求,就是在某种情况下,希望立即停止一个线程。 比如:做Android APP...

    Java线程中断的理解和正确使用

    1、为什么废弃Thread的stop函数?

    对于有多线程开发经验的开发者,应该大多数在开发过程中都遇到过这样的需求,就是在某种情况下,希望立即停止一个线程。

    比如:做Android APP开发,当打开一个界面时,需要开启线程请求网络获取界面的数据,但有时候由于网络特别慢,用户没有耐心等待数据获取完成就将界面关闭,此时就应该立即停止线程任务,不然一般会内存泄露,造成系统资源浪费,如果用户不断地打开又关闭界面,内存泄露会累积,最终导致内存溢出,APP闪退。

    可能有不少开发者用过Thread的stop去停止线程,当然此函数确实能停止线程,不过Java官方早已将它废弃,不推荐使用,这是为什么?

    1. stop是通过立即抛出ThreadDeath异常,来达到停止线程的目的,此异常抛出有可能发生在任何一时间点,包括在catch、finally等语句块中,但是此异常并不会引起程序退出(笔者只测试了Java8)。
    2. 由于有异常抛出,导致线程会释放全部所持有的锁,极可能引起线程安全问题。

    由于以上2点,stop这种方式停止线程是不安全的。

    下面是stop的源码(Java8):

        @Deprecated
        public final void stop() {
            SecurityManager security = System.getSecurityManager();
            if (security != null) {
                checkAccess();
                if (this != Thread.currentThread()) {
                    security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
                }
            }
            // A zero status value corresponds to "NEW", it can't change to
            // not-NEW because we hold the lock.
            if (threadStatus != 0) {
                resume(); // Wake up thread if it was suspended; no-op otherwise
            }
    
            // The VM can handle all thread states
            stop0(new ThreadDeath());
        }
        
        private native void stop0(Object o);
    

    上述源码中关键代码就是stop0(new ThreadDeath())函数,这是Native函数,传递的参数是ThreadDeath,ThreadDeath是一个异常对象,该对象从Native层抛到了Java层,从而导致线程停止,不过此异常并不会引起程序退出。

    很多时候为了保证数据安全,线程中会编写同步代码,如果当线程正在执行同步代码时,此时调用stop,引起抛出异常,导致线程持有的锁会全部释放,此时就不能确保数据的安全性,出现无法预期的错乱数据,还有可能导致存在需要被释放的资源得不到释放,引发内存泄露。所以用stop停止线程是不推荐的。

    2、用Thread的interrupt结束线程

    其实调用Thread对象的interrupt函数并不是立即中断线程,只是将线程中断状态标志设置为true,当线程运行中有调用其阻塞的函数(Thread.sleep,Object.wait,Thread.join等)时,阻塞函数调用之后,会不断地轮询检测中断状态标志是否为true,如果为true,则停止阻塞并抛出InterruptedException异常,同时还会重置中断状态标志;如果为false,则继续阻塞,直到阻塞正常结束。

    因此,可以利用这种中断机制来控制结束线程的运行。只要理解机制,代码的实现其实比较简单。

    2.1、结束未使用阻塞函数的线程

    public class Main {
    
        public static void main(String[] args) {
            InnerClass innerClass = new InnerClass();
            Thread thread = new Thread(innerClass);
            thread.start();
            long i = System.currentTimeMillis();
            while (System.currentTimeMillis() - i < 10 * 1000) {
                thread.isAlive();
            }
            thread.interrupt();
        }
    
        static class InnerClass implements Runnable {
    
            @Override
            public void run() {
                System.err.println("start work");
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("doing work");
                }
                System.err.println("done work");
            }
        }
    
    }
    

    思路其实就是用isInterrupted来判断线程是否处于中断状态,若是中断状态,则跳出正在执行的任务,使线程结束运行。

    2.2、结束使用阻塞函数的线程

    public class Main {
    
        public static void main(String[] args) {
            InnerClass innerClass = new InnerClass();
            Thread thread = new Thread(innerClass);
            thread.start();
            long i = System.currentTimeMillis();
            while (System.currentTimeMillis() - i < 10 * 1000) {
                thread.isAlive();
            }
            thread.interrupt();
        }
    
        static class InnerClass implements Runnable {
    
            @Override
            public void run() {
                System.err.println("start work");
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("doing work");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }
                System.err.println("done work");
            }
        }
    
    }
    

    思路同2.1,需要注意的是,调用sleep函数触发InterruptedException异常时,在catch代码块中需调用interrupt函数,使线程再次处于中断状态,使while循环条件为false,使线程跳出循环,结束运行。若不调用,while循环为死循环,线程无法结束。

    2.3、关于Thread的静态函数interrupted与Thread的对象函数isInterrupted

    先对比下2函数的源码:

        public static boolean interrupted() {
            return currentThread().isInterrupted(true);
        }
    
        public boolean isInterrupted() {
            return isInterrupted(false);
        }
    
        /**
         * Tests if some Thread has been interrupted.  The interrupted state
         * is reset or not based on the value of ClearInterrupted that is
         * passed.
         */
        private native boolean isInterrupted(boolean ClearInterrupted);
    

    从源码中可以看出,2函数都是调用了Native函数private native boolean isInterrupted(boolean ClearInterrupted);,前者调用传的参数为true,所以,调用interrupted函数,会在检测线程中断状态标志是否为true后,还会将中断状态标志重置为false。而isInterrupted函数只是检测线程中断状态标志。

    展开全文
  • 线程面试题(值得收藏)

    万次阅读 多人点赞 2019-08-16 09:41:18
    史上最强多线程面试47题(含答案),建议收藏 金九银十快到了,即将进入找工作的高峰期,最新整理的最全多线程并发面试47题和答案总结,希望对想进BAT的同学有帮助,由于篇幅较长,建议收藏后细看~ 1、并发编程三要素?...
  • 线程的thread.interrupt()方法是中断线程,将会设置该线程中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示位,以...
  • 在程序中,我们是不能随便中断一个线程的,因为这是极其不安全的操作,我们无法知道这个线程正运行在什么状态,它可能持有某把锁,强行中断可能导致锁不能释放的问题;或者线程可能在操作数据库,强行中断导致数据不...
  • 理解java线程中断(interrupt)

    万次阅读 多人点赞 2016-04-07 17:39:33
    一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果
  • 言归正传,说到线程中断线程中断分为两种:控制任务流程走向结束和异常中止。 而线程异常中止也分为两种:强制调用线程对象的stop方法(结果不可预料)以及捕获异常并中断。 所以,详细的方式其实是三种,...
  • Java线程中断理解(interrupte)

    千次阅读 2015-08-12 14:11:43
     一般而言,可能有三种原因引起阻塞:等待阻塞、同步阻塞以及其他阻塞(睡眠、jion或者IO阻塞);对于Java而言,等待阻塞是调用wait方法产生的,同步阻塞则是由同步块(synchronized)产生的,睡眠阻塞是由sleep...
  • 关于线程池运行过程中,业务逻辑出现未知异常导致线程中断问题反思 最近在项目研发中的关于线程池应用过程中由于业务逻辑异常导致的线程中断,但程序未中断导致的脏数据问题  话不多说,在最近最新的一个版本发布...
  • java线程中断机制

    2017-08-09 22:32:38
    1.线程进入阻塞状态有如下几个原因1.通过sleep使任务进入休眠状态 2.notify或notifyAll之前的被wait挂起的线程 3.任务在等待输入/输出 4.等待并发锁2.中断阻塞任务中断线程有两种方式: 1.调用希望被终止的线程的...
  • Java 线程阻塞、中断及优雅退出

    千次阅读 2018-07-18 20:39:44
    本文转自:Java 线程阻塞、中断及优雅退出 线程阻塞 一个线程进入阻塞状态的原因可能如下(已排除Deprecated方法): sleep() sleep()使当前线程进入停滞状态(阻塞当前线程),让出CUP的使用、目的是不让当前...
  • stop()方法在现在JDK中不推荐使用,原因是stop()方法过于暴力,强行把执行到一半的线程终止,可能会引起一些数据不一致的问题 在使用线程中,如果需要中断线程,不建议使用在线程内部定义一个Boolean 然后在外边...
  • Java基础知识---线程中断

    千次阅读 2016-05-14 12:51:05
    一、什么是线程切换,线程阻塞,线程中断? 线程切换:我们知道,CPU是以时间片进行线程调度的,一个线程在占有一个分配的时间片之后,CPU就会根据相应的策略进行线程的重新调度,这个过程会很大程度上参考线程的
  • 线程一直等待或突然中断问题排查

    千次阅读 2018-06-26 17:42:26
    线程一直等待或突然中断问题排查问题描述:这两天经常收到“锁占用超时”的告警短信,第一次查找问题,是“批扣发送渠道任务”的锁占用超时,但未定位到原因,先暂时改了锁的状态,继续做业务。到第二天又发告警短信...
  • Java线程中断

    2017-09-08 17:37:44
    Java的中断机制
  • java多线程高级-线程中断/阻塞(四) 线程中断/阻塞:interrupt/LockSupport 在Core Java中有这样一句话:”没有任何语言方面的需求要求一个被中断的程序应该终止。中断一个线程只是为了引起该线程的注意,被...
  • java多线程中断(interrupt)问题

    千次阅读 2017-07-21 09:23:08
    摘要在java中,想要让一个线程停下来,有三种办法: (1)采用退出标志,使得run方法执行完之后线程自然终止。 (2)使用stop强行终止线程,但该方法由于安全问题已经被deprecated。...(3)使用中断机制。
  • java线程技术7_线程中断

    千次阅读 2014-08-05 21:18:21
    1.中断概述  在多线程编程中经常会遇到需要中止线程的情况,比如...中断线程的三个相差函数  1.通过成员方法Thread.interrupt()来设置中断状态为true  2.通过成员方法Thread.isInterrupted()来获取中断状态  
  • 参考1:http://www.51ou.com/browse/java/21131_2.html ... 一、引入  java多线程中断有Stop和interrupt,此处不谈LockSupport。 ...1、Stop是立即将一个线程中断,并释放锁,如果线程刚好执行到一半,很容易
  • java 线程中断

    2015-03-21 00:35:38
    1.中断概述  在多线程编程中经常会遇到需要中止线程的情况,比如启动多个...中断线程的三个相差函数  1.通过成员方法Thread.interrupt()来设置中断状态为true  2.通过成员方法Thread.isInterrupted()来获取中断状态
  • 中断线程中断并不是真正的中断线程,而只设置标志位(中断位)来通知用户 public boolean isInterrupt() 判断Thread 对象是否中断 public static boolean interrupted 判断 当前线程是否中断,并且...
  • java线程中断线程Interrupted用法

    千次阅读 2016-06-08 09:46:06
    线程状态   Java虚拟机将线程运行过程分成四种状态 。 (1) New 新生;(2) Runnable 可运行;(3) Blocked 阻塞;(4) Dead 死亡。  值得注意的是: 线程的可运行状态并不代表线程一定在运行(runnable != ...
  • 最近想接触一下多线程编程,于是打算写个博客,自己学习
  • 中断线程

    2013-10-11 10:08:50
    线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步,取决于这个程序本身。线程会不时地检测这个中断标识位,以判断线程是否应该被中断(中断标识值是否为true)。它并不像stop方法那
  • 如下的代码, 演示了线程在sleep的过程中, 被中断的情况. 子线程每隔一秒打印当前的时间, 循环10次, 会执行10s. 主线程在其第六秒的时候, 让子线程休眠. 此时子线程抛出被中断的异常. import java.util.Da
  • 当一个线程调用interrupt时,线程中断标记位将被置位(置为true),线程会时不时地检测这个中断标记位,以判断线程是否应该被中断。 通过Thread.CurrentThread().isInterrupterd可以知道线程是否被置位

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,486
精华内容 22,194
关键字:

引起线程中断的原因