Java线程停止方法之Interrupt方法

  近年来在上学Java多线程相关的知识点,个中有关线程截止的措施网上也有成都百货上千大咖给出了详细的解答,而自笔者那边就当中Interrupt方法的瞩目点给协调提个醒。

  近来在就学Java二拾八线程相关的知识点,个中有关线程截止的主意网上也有比比皆是大牌给出了详细的解答,而自个儿那边就当中Interrupt方法的专注点给协调提个醒。

  首先依然大约的陈列下截止线程的形式:

  首先照旧大概的罗列下终止线程的办法:

  一、使用stop()方法等,不过已经不复被推荐应用,和suspend、resume一样。

  1、使用stop()方法等,可是已经不复被引入应用,和suspend、resume一样。

  二、使用退出标志终止线程,引进三个共享变量,volatile类型也许接纳synchronized来监视共享变量相关操作的法门,然后在run()方法中,通过while循环不停的轮询那几个标志。

  2、使用退出标志终止线程,引进1个共享变量,volatile类型或然应用synchronized来监视共享变量相关操作的办法,然后在run()方法中,通过while循环不停的轮询那个标志。

  3、使用Interrupt方法中断线程。

  三、使用Interrupt方法中断线程。

  注意点:笔者壹发轫看到该办法的时候,认为interrupt会使线程停止运作,但骨子里并非如此,调用1个线程的Interrupt方法会把线程的图景改为中断态。那些中又足以细分成七个方面:

  注意点:作者一开头看到该办法的时候,认为interrupt会使线程截至运转,但事实上并非如此,调用三个线程的Interrupt方法会把线程的情景改为中断态。那几个中又能够细分成八个地方:

  一)对于因履行了sleep、wait、join方法而休眠的线程:调用Interrupt方法会使他们不再休眠,同时会抛出
InterruptedException极度。比如多少个线程A正在sleep中,那时候此外三个先后里去调用A的interrupt方法,那时就会迫使A停止休眠而抛出InterruptedException极度,从而提前使线程逃离阻塞状态。

  1)对于因实施了sleep、wait、join方法而休眠的线程:调用Interrupt方法会使他们不再休眠,同时会抛出
InterruptedException至极。比如贰个线程A正在sleep中,那时候此外1个程序里去调用A的interrupt方法,那时就会迫使A结束休眠而抛出InterruptedException非凡,从而提前使线程逃离阻塞状态。

  二)对周丽娟在周转的线程,即未有阻塞的线程,调用Interrupt方法就只是把线程A的情景改为interruptted,不过不会潜移默化线程A的继续执行。

  贰)对高尚在运转的线程,即未有阻塞的线程,调用Interrupt方法就只是把线程A的意况改为interruptted,可是不会潜移默化线程A的继续执行。

 

 

以下是对地处阻塞状态线程使用Interrupt方法的例证:

以下是对地处阻塞状态线程使用Interrupt方法的例证:

 1 class MyThread extends Thread {  
 2     volatile boolean stop = false;  
 3     public static void main( String args[] ) throws Exception {  
 4         MyThread thread = new MyThread();  
 5         System.out.println( "Starting thread..." );  
 6         thread.start();  
 7         Thread.sleep( 3000 );  
 8         System.out.println( "hread stop..." );  
 9         thread.stop = true;  //如果线程阻塞,将不会检查此变量  
10         thread.interrupt();  
11         Thread.sleep( 3000 );  
12         System.out.println( "end..." );  
13     }  
14   
15     public void run() {  
16         while ( !stop ) {  
17              System.out.println( "Thread running..." );  
18              try {  
19                  Thread.sleep( 1000 );  
20              } catch ( InterruptedException e ) {  
21                  System.out.println( "Thread interrupted..." );  
22              }  
23         }  
24         System.out.println( "Thread exiting under request..." );  
25     }  
26 }                
 1 class MyThread extends Thread {  
 2     volatile boolean stop = false;  
 3     public static void main( String args[] ) throws Exception {  
 4         MyThread thread = new MyThread();  
 5         System.out.println( "Starting thread..." );  
 6         thread.start();  
 7         Thread.sleep( 3000 );  
 8         System.out.println( "hread stop..." );  
 9         thread.stop = true;  //如果线程阻塞,将不会检查此变量  
10         thread.interrupt();  
11         Thread.sleep( 3000 );  
12         System.out.println( "end..." );  
13     }  
14   
15     public void run() {  
16         while ( !stop ) {  
17              System.out.println( "Thread running..." );  
18              try {  
19                  Thread.sleep( 1000 );  
20              } catch ( InterruptedException e ) {  
21                  System.out.println( "Thread interrupted..." );  
22              }  
23         }  
24         System.out.println( "Thread exiting under request..." );  
25     }  
26 }                

  表明:对于被上述三种办法阻塞的线程,正确的告1段落线程形式是安装共享变量,并调用interrupt()(注意变量应该先安装)。设置共享变量是为着没有被堵塞的线程也能健康退出。

  表明:对于被上述两种艺术阻塞的线程,正确的平息线程方式是设置共享变量,并调用interrupt()(注意变量应该先安装)。设置共享变量是为了未有被打断的线程也能健康退出。



 

 

  以下内容还在持续研讨中

  以下内容还在继续商量中

  在看1些博主的稿蛇时还察看了1些奇异意况,也在这边做个补充:

  在看有些博主的篇章时还见到了壹部分特有情况,也在那边做个补充:

  线程在I/O操作举办时被打断

  线程在I/O操作进行时被卡住

  分三种情状:

  分三种景况:

  1)使用通道(channels)的意况,通道是Java 1.四引进的I/O
API,被堵塞的线程将选择3个ClosedByInterruptException很是。那与运用Interrupt方法抛出卓殊的用法壹样,只是万分分化而已。

  壹)使用通道(channels)的情况,通道是Java 1.四引进的I/O
API,被卡住的线程将选用3个ClosedByInterruptException十分。那与使用Interrupt方法抛出分外的用法①样,只是那1个分化而已。

  贰)使用古板的I/O。

  二)使用古板的I/O。

  表明:即使Interrupt方法被调用了,Thread.interrupt()也不起作用,因为线程将不会脱离被阻塞状态。

  表明:即使Interrupt方法被调用了,Thread.interrupt()也不起成效,因为线程将不会退出被阻塞状态。

  化解办法:调用阻塞该线程的套接字的close()方法。在那种情形下,要是线程被I/O操作阻塞,该线程将收取到1个SocketException十分,那与应用interrupt()方法引起一个InterruptedException分外被抛出13分相像。

  化解办法:调用阻塞该线程的套接字的close()方法。在那种处境下,如若线程被I/O操作阻塞,该线程将收取到贰个SocketException很是,那与使用interrupt()方法引起二个InterruptedException极度被抛出十一分相像。

葡京娱乐网,  注意:唯1要表达的是,必须存在socket的引用(reference),唯有如此close()方法才能被调用。那象征socket对象必须被共享。

  注意:唯壹要证实的是,必须存在socket的引用(reference),唯有如此close()方法才能被调用。那代表socket对象必须被共享。

  以下代码供参考:

  以下代码供参考:

  

  

class MyThread extends Thread {  
    volatile boolean stop = false;  
    volatile ServerSocket socket;  

    public static void main( String args[] ) throws Exception {  
        MyThread thread = new MyThread();  
        System.out.println( "Starting thread..." );  
        thread.start();  
        Thread.sleep( 3000 );  
        System.out.println( "Asking thread to stop..." );  
        thread.stop = true;  
        thread.socket.close();  
        Thread.sleep( 3000 );  
        System.out.println( "Stopping application..." );    
     } 

    public void run() {  
        try {  
            socket = new ServerSocket(7856);  
        } catch ( IOException e ) {  
            System.out.println( "Could not create the socket..." );  
            return;  
        }  
        while ( !stop ) {  
            System.out.println( "Waiting for connection..." );  
            try {  
                Socket sock = socket.accept();  
            } catch ( IOException e ) {  
                System.out.println( "accept() failed or interrupted..." );  
            }  
        }  
        System.out.println( "Thread exiting under request..." );  
    }  
} 
class MyThread extends Thread {  
    volatile boolean stop = false;  
    volatile ServerSocket socket;  

    public static void main( String args[] ) throws Exception {  
        MyThread thread = new MyThread();  
        System.out.println( "Starting thread..." );  
        thread.start();  
        Thread.sleep( 3000 );  
        System.out.println( "Asking thread to stop..." );  
        thread.stop = true;  
        thread.socket.close();  
        Thread.sleep( 3000 );  
        System.out.println( "Stopping application..." );    
     } 

    public void run() {  
        try {  
            socket = new ServerSocket(7856);  
        } catch ( IOException e ) {  
            System.out.println( "Could not create the socket..." );  
            return;  
        }  
        while ( !stop ) {  
            System.out.println( "Waiting for connection..." );  
            try {  
                Socket sock = socket.accept();  
            } catch ( IOException e ) {  
                System.out.println( "accept() failed or interrupted..." );  
            }  
        }  
        System.out.println( "Thread exiting under request..." );  
    }  
} 

如上是和谐对下马线程方法的1些总括,当然也是借鉴了层见迭出博主的享受。重点放在了Interrupt方法,因为那边不难明白出错!

上述是温馨对下马线程方法的一对总计,当然也是以史为鉴了好多博主的享用。重点放在了Interrupt方法,因为那边不难通晓出错!