精华内容
下载资源
问答
  • 有关线程中断和线程阻塞

    千次阅读 2014-05-24 15:49:30
    一个线程都要从运行到结束都要经过3个阶段: 1、正在运行 2、准备结束运行 ... 2、使用thread.interrupt()方法发送中断。 3、在Thread对象中设置共享变量,通过在run方法中不断检测该变量的值来决定是否结束。

    一个线程都要从运行到结束都要经过3个阶段:

         1、正在运行

         2、准备结束运行

         3、结束运行

    那么怎么结束这个线程呢?可以通过下面这三个方法结束一个线程。

         1、使用stop()方法强制结束线程。

         2、使用thread.interrupt()方法发送中断。

         3、在Thread对象中设置共享变量,通过在run方法中不断检测该变量的值来决定是否结束。

    第一种方法,stop()方法。 

    臭名昭著的stop()停止线程的方法已不提倡使用了,原因是什么呢?当在一个线程对象上调用stop()方法时,这个线程对象所运行的线程就会立即停止,并抛出特殊的ThreadDeath()异常。这里的“立即”因为太“立即”了,假如一个线程正在执行:

    synchronized void {
     x = 3;
     y = 4;
    }
    由于方法是同步的,多个线程访问时总能保证x,y被同时赋值,而如果一个线程正在执行到x = 3;时,被调用了 stop()方法,即使在同步块中,它也干脆地stop了,这样就产生了不完整

    的残废数据。而多线程编程中最最基础的条件要保证数据的完整性,所以请忘记 线程的stop方法,以后我们再也不要说“停止线程”了。


    第二种方法,中断线程。

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

    当我们调用thread.interrupt()方法时,会将thread的中断标志位设为true。通过isInterrupted()方法可以判断标志位是否为true。此后程序是该继续还是结束就取决于程序本身了。

    注意如果一个线程处于了阻塞状态(如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态),则在线程在检查中断标识时如果发现中断标示为true,则会在这些阻塞方法(sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法)调用处抛出InterruptedException异常,并且在抛出异常后立即将线程的中断标别位清除,即重新设置为false。抛出异常是为了线程从阻塞状态醒过来,并在结束线程前让程序员有足够的时间来处理中断请求。一个抛出了InterruptedException的线程的状态马上就会被置为非中断状态,如果catch语句没有处理异常,则下一 次循环中isInterrupted()为false,线程会继续执行,可能你N次抛出异常,也无法让线程停止。例如下面例子:

    public class ThreadA extends Thread {
       int count=0;
       public void run(){
           System.out.println(getName()+"将要运行...");
           while(!this.isInterrupted()){
               System.out.println(getName()+"运行中"+count++);
               try{
                   Thread.sleep(400);
               }catch(InterruptedException e){
                   System.out.println(getName()+"从阻塞中退出...");
                   System.out.println("this.isInterrupted()="+this.isInterrupted());
               }
           }
           System.out.println(getName()+"已经终止!");
       }
    }
    因为上例中try在while循环里面,当检测到异常时会执行打印语句,当再次进行while(!this.isInterrupted())判定的时候,请注意,由于此时中断标志位已经被重置为false了,所以while循环会一直继续下去。

    public class ThreadA extends Thread {
       int count=0;
       public void run(){
           System.out.println(getName()+"将要运行...");
           while(!this.isInterrupted()){
               System.out.println(getName()+"运行中"+count++);
               try{
                   Thread.sleep(400);
               }catch(InterruptedException e){
    	       this.interrupt();
                   System.out.println(getName()+"从阻塞中退出...");
                   System.out.println("this.isInterrupted()="+this.isInterrupted());
               }
           }
           System.out.println(getName()+"已经终止!");
       }
    }

    比较良好处理方法是:

    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 {   
            //线程结束前做一些清理工作   
        }   
    }

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

    另外不要在你的底层代码里捕获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().interrupted();   
        }   
        ...   
    }

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

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

    第三个方法,设置中断信号量。

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

    package com.ljq.test;
    
    public class ThreadTest extends Thread{
        //线程中断信号量
        volatile boolean stop=false; 
        
        public static void main(String[] args) throws Exception {
            ThreadTest thread=new ThreadTest();
            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...");  
        }
        
        
        @Override
        public void run() {
            //每隔一秒检测一下中断信号量
            while(!stop){
                System.out.println("Thread is running!");
                long begin=System.currentTimeMillis();
                /**
                 * 使用while循环模拟sleep方法,这里不要使用sleep,否则在阻塞时会抛InterruptedException异常而退出循环,
                 * 这样while检测stop条件就不会执行,失去了意义。 
                 */
                while ((System.currentTimeMillis() - begin < 1000)) {
                    
                }   
            }
            System.out.println("Thread exiting under request!");   
        }
    }

    注意:这里将stop变量定义为volatile类型,防止由于本地缓存产生错误。

    参考文章: 

    http://www.cnblogs.com/linjiqin/archive/2011/04/11/2012695.html

    http://blog.csdn.net/oscar999/article/details/1755759



    展开全文
  • 中断线程

    千次阅读 2016-09-12 16:59:03
    中断线程 线程的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().interrupted();   
        }   
        ...   
    }  
    复制代码

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

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

            

       

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

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

    复制代码
    package com.ljq.test;
    
    public class ThreadTest extends Thread{
        //线程中断信号量
        volatile boolean stop=false; 
        
        public static void main(String[] args) throws Exception {
            ThreadTest thread=new ThreadTest();
            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...");  
        }
        
        
        @Override
        public void run() {
            //每隔一秒检测一下中断信号量
            while(!stop){
                System.out.println("Thread is running!");
                long begin=System.currentTimeMillis();
                /**
                 * 使用while循环模拟sleep方法,这里不要使用sleep,否则在阻塞时会抛InterruptedException异常而退出循环,
                 * 这样while检测stop条件就不会执行,失去了意义。 
                 */
                while ((System.currentTimeMillis() - begin < 1000)) {
                    
                }   
            }
            System.out.println("Thread exiting under request!");   
        }
    }
    复制代码

    运行结果如下:

                

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

    复制代码
    package com.ljq.test;
    
    public class ThreadTest extends Thread{
        
        public static void main(String[] args) throws Exception {
            ThreadTest thread=new ThreadTest();
            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...");  
        }
        
        
        @Override
        public void run() {
            //每隔一秒检测一下中断信号量
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("Thread is running!");
                long begin=System.currentTimeMillis();
                /**
                 * 使用while循环模拟sleep方法,这里不要使用sleep,否则在阻塞时会抛InterruptedException异常而退出循环,
                 * 这样while检测stop条件就不会执行,失去了意义。 
                 */
                while ((System.currentTimeMillis() - begin < 1000)) {
                    
                }   
            }
            System.out.println("Thread exiting under request!");   
        }
    }
    复制代码

       

    到目前为止一切顺利!但是,当线程等待某些事件发生而被阻塞,又会发生什么?当然,如果线程被阻塞,它便不能核查共享变量,也就不能停止。这在许多情况下会发生,例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时,这里仅举出一些。
    他们都可能永久的阻塞线程。即使发生超时,在超时期满之前持续等待也是不可行和不适当的,所以,要使用某种机制使得线程更早地退出被阻塞的状态。下面就来看一下中断阻塞线程技术。

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

     

    复制代码
    package com.ljq.test;
    
    public class ThreadTest extends Thread{
        
        public static void main(String[] args) throws Exception {
            ThreadTest thread=new ThreadTest();
            System.out.println("Starting thread...");   
            thread.start();   
            Thread.sleep(3000);   
            thread.interrupt();// 等中断信号量设置后再调用 
            System.out.println("Asking thread to stop...");   
            Thread.sleep(3000);   
            System.out.println("Stopping application...");  
        }
        
        
        @Override
        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();  
                    e.printStackTrace();
                }
            }
            System.out.println("Thread exiting under request...");   
        }
    }
    复制代码

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

                  

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

    复制代码
    package com.ljq.test;
    
    public class ThreadTest 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...");
        }
    
        private 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()将不起作用,因为线程将不会退出被阻塞状态。尽管interrupt()被调用,线程也不会退出被阻塞状态,比如ServerSocket的accept方法根本不抛出异常。

                     

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

    复制代码
    package com.ljq.test;
    
    import java.io.IOException;
    import java.net.ServerSocket;
    
    public class ThreadTest extends Thread {
        volatile ServerSocket socket;
    
        public static void main(String args[]) throws Exception {
            ThreadTest thread = new ThreadTest();
            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(3036);
            } 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...");
        }
    }
    复制代码
    展开全文
  • java中断和线程结束深入探讨

    千次阅读 2011-09-21 16:20:36
    中断:  有软中断和中断之分。而硬中断多为外围设备引起而且发生多是随机的,故我们在这里只讨论java程序中的软中断,是可控的。  这里我必须要回答几个问题,然而是网上大多数文章...c)中断和结束线程之间有什
    中断: 
    有软中断和硬中断之分。而硬中断多为外围设备引起而且发生多是随机的,故我们在这里只讨论java程序中的软中断,是可控的。 

    这里我必须要回答几个问题,然而是网上大多数文章没有回答的。 
    a)为什么使用中断? 
    b)何时使用中断? 
    c)中断和结束线程之间有什么关系? 
    d)中断是否就是结束线程? 

    a)在java中我们引入中断的目的是为了打断线程现在所处的某种状态,但是我们知道这种状态一定是阻塞状态; 
    b)上面已经说了是在线程阻塞的时候,我们想要改变它阻塞的状态,所以通常在线程sleep,wait,join的情况下我们可以使用中断; 
    c)由于中断可以捕获,通过这种方式我们可以结束线程; 
    d)中断不是结束线程,只不过发送了一个中断信号而已,线程要退出还要我们加上自己的结束线程的操作。 

    上面说了中断使用的情况也就是scope,那么也就说明了线程在某些情况是不可中断的,换句话说,是捕获不到中断信号的。 

    我们现在将中断分为两种情况: 
    可中断的阻塞和不可中断的阻塞 

    对于可中断的阻塞情况我们要怎么结束这样的线程呢?下面举个简单的例子; 

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

    通过在另外一个线程或者主线程里面调用要结束或者中断线程的句柄执行interrupt()方法,然后在该线程里面去捕获中断,从而退出run()方法;当然上面也可以用bool值的方式,在捕获到中断后修改bool值达到退出run方法的目的。上面的例子都是用于wait,join的情况。 

    谈到不可中断的阻塞,由于线程阻塞不可能被中断,或者不具备被中断的条件,所以我们会考虑到一些不同的处理方式: 
    一是引入条件可以让该不可中断的线程能够被中断,比如在read的循环里面加个sleep函数,这样就可以捕获中断异常从而达到退出的目的了; 
    二是我们还是可以引入一个valotile的bool值的方式,线程要结束时,在循环里面去修改,注意这里有一个前提是有一个循环,并且循环执行一次的时间很短; 
    三是书上和网上将的情况,socket的处理是用关闭socket的方式也就是关闭底层资源的方式来捕获异常达到退出的目的; 

    四也是网上和书上讲到的对被加锁的块(synchronized方法和临界区)进行中断采用ReentrantLock可以捕获中断。


    展开全文
  • 如何中断当前线程

    千次阅读 2017-12-29 22:38:08
    由于第一种方式是不安全的,所以本篇文章不做讨论,主要分享一下如何使用interrupt()方法来中断线程。 采用interrupt中止线程 Thread类中提供了三个中断线程的方法,如下图:  方法详情:  - ...

    如何中断当前线程

    中断当前线程有两种方式。第一种方式是通过调用线程的stop()方法,第二种方式通过调用interrupt()方法。 
    由于第一种方式是不安全的,所以本篇文章不做讨论,主要分享一下如何使用interrupt()方法来中断线程。

    采用interrupt中止线程

    Thread类中提供了三个中断线程的方法,如下图: 
    这里写图片描述
    这里写图片描述
    方法详情: 
    - interrupt():中断当前线程。该方法仅设置当前线程的状态为中断,实际上并不中断线程的运行。如果要中断线程的运行,还需要当前线程自己中断 
    - interrupted():测试当前线程的状态是否被中断。使用这个方法会清除当前线程的状态。简言之,如果这个方法被调用了两次,那么第二次会返回false. 除非当前线程在第二次调用之前,第一次清除线程状态之后,再次再中断。 
    - isInterrupted():测试当前线程的状态是否被中断。这个方法与interrupted()这个方法最大的差异是isInterrupted()方法不会清除当前线程的状态。

    代码示例

    public class ThreadInterruptDemo implements Runnable {
    
        @Override
        public void run() {
    
    //        System.out.println("第一次调用Thread.interrupted()" + Thread.interrupted());
    //        System.out.println("第二次调用Thread.interrupted()" + Thread.interrupted());
    
            /**
             * isInterrupted()
             * 用来测试当前线程的运行状态
             * true:表示当前线程为中断状态
             * false:表示当前线程为运行状态
             * 可以通过这样的方法来中断线程运行
             */
            if (Thread.currentThread().isInterrupted()){
                System.out.println("由于线程状态是中断,所以return不再执行线程任务");
                return;
            }
    
            while (true) {
                try {
                    Thread.sleep(3L);
                    System.out.println("线程正在执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
    
        }
    
        public static void main(String[] args) {
            Thread thread = new Thread(new ThreadInterruptDemo(), "ThreadInterruptDemo");
            // 开启线程
            thread.start();
    
            /**
             * 中断当前线程
             * 该方法仅设置当前线程的状态为中断,实际上并不中断线程的运行
             * 如果要中断线程的运行,还需要当前线程自己中断
             */
            thread.interrupt();
        }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    源代码链接: 
    https://github.com/myNameIssls/javase-study/blob/master/javase-multithreading/src/main/java/cn/tyrone/javase/thread/ThreadInterruptDemo.java 
    参考链接: 
    https://docs.oracle.com/javase/8/docs/api/ 
    https://www.cnblogs.com/w-wfy/p/6414801.html 
    http://blog.csdn.net/paincupid/article/details/47626819

    展开全文
  • 内核线程、软中断和定时器有何区别? 在慢速中断的过程中,允许别的中断发生      Re: 内核线程、软中断和定时器有何区别? 2.4中还有慢速中断吗?  ...
  • 理解了线程同步和线程通信之后,再来看本文的知识点就会简单的多了,本文是做为传统线程知识点的一个补充。有人会问:JDK5之后有了更完善的处理多线程问题的类(并发包),我们还需要去了解传统线程吗?答:需要。
  • 协程和线程区别

    万次阅读 2020-09-16 22:19:29
    线程是进程的一个实体,是CPU调度分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器栈),但是它可与同属一个进程的...
  • 中断优先级和中断线程优先级

    千次阅读 2017-11-12 15:40:00
    中断是一种当今很重要的硬件与cpu通信的方式,主板上集成很多硬件,那么就可以认为会有很多中断,但是cpu的数目往往要少得多,那么肯定会有多个硬件中断竞争一个cpu的情况,任何系统(包括自然界)都不能乱套,肯定...
  • 中断线程化的意义在于:在 Linux 中,中断具有最高的优先级。不论在任何时刻,只要产生中断事件,内核将立即执行相应的中断处理程序,等到所有挂起的中断软中断处理完毕后才能执行正常的任务,因此有可能造成实时...
  • linux 中断线程

    千次阅读 2017-05-27 12:24:01
    为什么要进行中断线程化? 在 Linux 中,中断具有最高的优先级。不论在任何时刻,只要产生中断事件,内核将立即执行相应的中断处理程序,等到所有挂起的中断软中断处理完毕后才能执行正常的任务,因此有可能造成...
  • Java多线程——1 中断线程

    千次阅读 2013-08-08 00:59:03
    一、中断线程(标识true) 线程的thread.interrupt()方法是中断线程,将会设置该线程为中断状态,即设置为true。线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步,取决于这个程序本身。线程会不时地...
  • 正确中断java线程

    万次阅读 2007-08-23 11:25:00
    不提倡的stop()方法 臭名昭著的stop()停止线程的方法已不提倡使用了,原因是什么呢? 当在一个线程对象上调用stop()方法时,这个线程对象所运行的线程就会立即停止,并抛出特殊的ThreadDeath()异常。这里的“立即”...
  • 线程中断详解

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

    千次阅读 2014-04-08 15:40:33
    中断线程时,这个线程的中断状态将被设置为true,在Thread中,有以下三个方法中断线程和查询线程中断状态的方法。 public class Tread{  public void interrupt(){....}  public boolean isInterrupted(){.......
  • 线程中断机制

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

    千次阅读 2012-05-08 11:29:58
    中断线程化之后,中断将作为内核线程运行而且被赋予不同的实时优先级,实时任务可以有比中断线程更高的优先级。这样,具有最高优先级的实时任务就能得到优先处理,即使在严重负载下仍有实时性保证。but,并
  • java 多线程-02-线程中断 interrupt()

    万次阅读 2021-06-11 09:34:03
    线程的Thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,完全取决于目标线程的自行决定。线程会不时地检测这个中断标志...
  • 主要讲解线程中断,以及停止线程的方式,并且进行了相关的代码演示。
  • 如何优雅的中断线程

    千次阅读 2019-08-22 22:15:18
    有时候我们需要中断一个线程。由于启动一个线程的方法是start(),所以终止一个线程很容易想到stop(),JDK在 java.lang.Thread类中确实提供了一个stop()方法,这个方法的作用是强制停止一个线程。但是从jdk1.2开始就...
  • 1.线程可以被sleep()中断,但这种中断属于阻塞线程线程仍然可以获得cpu的执行权,如果睡眠中的线程不是后台进程且当主线程执行完时jvm不会停止还会等到睡眠中的线程。当然如果睡眠中被interrupted中断会抛出异常...
  • 进程和线程区别

    万次阅读 多人点赞 2016-06-27 20:53:51
    1、进程和线程区别? 解析:(1)进程是资源的分配调度的一个独立单元,而线程是CPU调度的基本单元  (2)同一个进程中可以包括多个线程,并且线程共享整个进程的资源(寄存器、堆栈、上下文),一个进行至少...
  • boost线程中断

    千次阅读 2017-04-14 11:38:14
    模拟功能:线程中断 boost::this_thread::interruption_point() 一个对话框应用程序,界面上有两个按钮,一个是“开始”一个是“退出”,点击“开始”时创建一个线程, 这个线程会执行一个任务,whatever,可能是下载...
  • java多线程--中断线程

    千次阅读 2016-06-23 15:39:33
    2. 终止线程的方式 Thread中的stop()suspend()方法,由于固有的不安全性,已经...通常,我们通过“中断”方式终止处于“阻塞状态”的线程。 当线程由于被调用了sleep(), wait(), join()等方法而进入阻塞状态;若此
  • python手动中断线程程序方法详解

    千次阅读 2017-05-22 12:48:59
    本文大家分享的主要是Python手动中断线程程序相关内容,一起来看看吧,希望对大家学习python有所帮助。  引  灵感来源依旧是爬虫框架项目 pycrawler ,爬虫作为子线程运行时不受键盘中断信号影响,Ctrl-C...
  • 今天开始就来总结一下java多线程的...3.中断线程和守护线程以及线程优先级 4.线程的状态转化关系 1.什么是线程以及多线程与进程的区别  在现代操作在运行一个程序时,会为其创建一个进程。例如启动一个QQ程序,操作
  • 线程的停止和中断

    千次阅读 2019-04-22 13:01:25
    4.interrupt方法中断线程, 需要主动编码配合,写中断逻辑,但是可控。 调用interrupt()方法只是打了个退出标志,并非真正的退出,退出逻辑需要自己写。 package ThreadCheat1.interrupt; /**...
  • 多线程——2如何正确的中断线程

    千次阅读 2019-11-02 10:28:33
    线程探险——2常用方法 一、内容安排 什么是守护线程(Daemon Thread) Join方法的含义 自己join自己会是什么效果 Interrupt方法 综合案列:如何去停止线程 二、文章内容 1. 什么...
  • 在平时工作中,经常会听到应用程序的进程和线程的概念,那么它们两个之间究竟有什么关系或不同呢?一、对比进程和线程 1)两者概念 . 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 285,287
精华内容 114,114
关键字:

中断和线程的区别