Java多线程之中断机制（stop（）、interrupted（）、isInterrupted（））

一，介绍本文记录Java多线程中的中断机制的一些知识点。主要是stop方法、interrupted（）与isInterrupted（）方法的区别，并从源代码的实现上进行简单分析。Java中有3种方式可以终止正在运行的线程①线程正常退出，即run（）方法执行完毕了②使用Thread类中的stop（）方法强行终止线程。但stop（）方法已经过期了，不推荐使用③使用中断机制线程正常退出没有什么东东，中断机制下面详细介绍，先看下stop（）方法的源代码，关键是源代码上的注释。它解释了为什么stop（）不安全，stop（）方法停止的是哪个线程？ 1 /** 2* Forces the thread to stop executing. 3* 4* If there is a security manager installed, its <code>checkAccess</code> 5* method is called with <code>this</code> 6* as its argument. This may result in a 7* <code>SecurityException</code> being raised （in the current thread）. 8* 9* If this thread is different from the current thread （that is, the current10* thread is trying to stop a thread other than itself）, the11* security manager"s <code>checkPermission</code> method （with a12* <code>RuntimePermission（"stopThread"）</code> argument） is called in13* addition.14* Again, this may result in throwing a15* <code>SecurityException</code> （in the current thread）.16* 17* The thread represented by this thread is forced to stop whatever18* it is doing abnormally and to throw a newly created19* <code>ThreadDeath</code> object as an exception.20* 21* It is permitted to stop a thread that has not yet been started.22* If the thread is eventually started, it immediately terminates.23* 24* An application should not normally try to catch25* <code>ThreadDeath</code> unless it must do some extraordinary26* cleanup operation （note that the throwing of27* <code>ThreadDeath</code> causes <code>finally</code> clauses of28* <code>try</code> statements to be executed before the thread29* officially dies）.If a <code>catch</code> clause catches a30* <code>ThreadDeath</code> object, it is important to rethrow the31* object so that the thread actually dies.32* 33* The top-level error handler that reacts to otherwise uncaught34* exceptions does not print out a message or otherwise notify the35* application if the uncaught exception is an instance of36* <code>ThreadDeath</code>.37*38* @exceptionSecurityExceptionif the current thread cannot39* modify this thread.40* @see#interrupt（）41* @see#checkAccess（）42* @see#run（）43* @see#start（）44* @seeThreadDeath45* @seeThreadGroup#uncaughtException（Thread,Throwable）46* @seeSecurityManager#checkAccess（Thread）47* @seeSecurityManager#checkPermission48* @deprecated This method is inherently unsafe.Stopping a thread with49* Thread.stop causes it to unlock all of the monitors that it50* has locked （as a natural consequence of the unchecked51* <code>ThreadDeath</code> exception propagating up the stack）.If52* any of the objects previously protected by these monitors were in53* an inconsistent state, the damaged objects become visible to54* other threads, potentially resulting in arbitrary behavior.Many55* uses of <code>stop</code> should be replaced by code that simply56* modifies some variable to indicate that the target thread should57* stop running.The target thread should check this variable58* regularly, and return from its run method in an orderly fashion59* if the variable indicates that it is to stop running.If the60* target thread waits for long periods （on a condition variable,61* for example）, the <code>interrupt</code> method should be used to62* interrupt the wait.63* For more information, see64* <a href="{@docRoot}/../technotes/guides/concurrency/threadPrimitiveDeprecation.html">Why65* are Thread.stop, Thread.suspend and Thread.resume Deprecated？</a>.66*/67 @Deprecated68 public final void stop（） {69 stop（new ThreadDeath（））;70 }上面注释，第9行到第16行表明，stop（）方法可以停止“其他线程”。执行thread.stop（）方法这条语句的线程称为当前线程，而“其他线程”则是调用thread.stop（）方法的对象thread所代表的线程。如：1 public static void main（String[] args） {2 MyThread thread = new MyThread...3 //.....4 thread.stop（）;5 //....6 }在main方法中，当前线程就是main线程。它执行到第4行，想把“其他线程”thread“ 给停止。这个其他线程就是MyThread类 new 的thread对象所表示的线程。第21行至23行表明，可以停止一个尚未started（启动）的线程。它的效果是：当该线程启动后，就立马结束了。第48行以后的注释，则深刻表明了为什么stop（）方法被弃用！为什么它是不安全的。比如说，threadA线程拥有了监视器，这些监视器负责保护某些临界资源，比如说银行的转账的金额。当正在转账过程中，main线程调用 threadA.stop（）方法。结果导致监视器被释放，其保护的资源（转账金额）很可能出现不一致性。比如，A账户减少了100，而B账户却没有增加100二，中断机制JAVA中如何正确地使用中断机制的细节太多了。interrupted（）方法与 isInterrupted（）方法都是反映当前线程的是否处于中断状态的。①interrupted（） 1 /** 2* Tests whether the current thread has been interrupted.The 3* interrupted status of the thread is cleared by this method.In 4* other words, if this method were to be called twice in succession, the 5* second call would return false （unless the current thread were 6* interrupted again, after the first call had cleared its interrupted 7* status and before the second call had examined it）. 8* 9* A thread interruption ignored because a thread was not alive10* at the time of the interrupt will be reflected by this method11* returning false.12*13* @return<code>true</code> if the current thread has been interrupted;14*<code>false</code> otherwise.15* @see #isInterrupted（）16* @revised 6.017*/18 public static boolean interrupted（） {19 return currentThread（）.isInterrupted（true）;20 }从源码的注释中看出，它测试的是当前线程（current thread）的中断状态，且这个方法会清除中断状态。②isInterrupted（） 1 /** 2* Tests whether this thread has been interrupted.The interrupted 3* status of the thread is unaffected by this method. 4* 5* A thread interruption ignored because a thread was not alive 6* at the time of the interrupt will be reflected by this method 7* returning false. 8* 9* @return<code>true</code> if this thread has been interrupted;10*<code>false</code> otherwise.11* @see #interrupted（）12* @revised 6.013*/14 public boolean isInterrupted（） {15 return isInterrupted（false）;16 }从源码注释中可以看出，isInterrupted（）方法不会清除中断状态。③interrupted（）方法与 isInterrupted（）方法的区别从源代码可以看出，这两个方法都是调用的isInterrupted（boolean ClearInterrupted）,只不过一个带的参数是true，另一个带的参数是false。1 /**2* Tests if some Thread has been interrupted.The interrupted state3* is reset or not based on the value of ClearInterrupted that is4* passed.5*/6 private native boolean isInterrupted（boolean ClearInterrupted）;因此，第一个区别就是，一个会清除中断标识位，另一个不会清除中断标识位。再分析源码，就可以看出第二个区别在return 语句上：public static boolean interrupted（） {return currentThread（）.isInterrupted（true）;}/************************/public boolean isInterrupted（） {return isInterrupted（false）;}interrupted（）测试的是当前的线程的中断状态。而isInterrupted（）测试的是调用该方法的对象所表示的线程。一个是静态方法（它测试的是当前线程的中断状态），一个是实例方法（它测试的是实例对象所表示的线程的中断状态）。下面用个具体的例子来更进一步地阐明这个区别。有一个自定义的线程类如下：1 public class MyThread extends Thread {2 @Override3 public void run（） {4 super.run（）;5 for （int i = 0; i < 500000; i++） {6 System.out.println（"i=" + （i + 1））;7 }8 }9 } 先看interrupted（）方法的示例： 1 public class Run { 2 public static void main（String[] args） { 3 try { 4 MyThread thread = new MyThread（）; 5 thread.start（）; 6 Thread.sleep（1000）; 7 thread.interrupt（）; 8 //Thread.currentThread（）.interrupt（）; 9 System.out.println（"是否停止1？="+thread.interrupted（））;//false10 System.out.println（"是否停止2？="+thread.interrupted（））;//false main线程没有被中断！！！
//......第5行启动thread线程，第6行使main线程睡眠1秒钟从而使得thread线程有机会获得CPU执行。main线程睡眠1s钟后，恢复执行到第7行，请求中断 thread线程。第9行测试线程是否处于中断状态，这里测试的是哪个线程呢？？？答案是main线程。因为：（1）interrupted（）测试的是当前的线程的中断状态（2）main线程执行了第9行语句，故main线程是当前线程再看isInterrupted（）方法的示例：1 public class Run3 {2 public static void main（String[] args） {3 try {4 MyThread thread = new MyThread（）;5 thread.start（）;6 Thread.sleep（1000）;7 thread.interrupt（）;8 System.out.println（"是否停止1？="+thread.isInterrupted（））;//true在第8行，是thread对象调用的isInterrupted（）方法。因此，测试的是thread对象所代表的线程的中断状态。由于在第7行，main线程请求中断 thread线程，故在第8行的结果为: true本文永久更新链接地址：http://www.linuxidc.com/Linux/2016-05/131104.htm