java isinterrupted_JAVA多线程之中断机制stop()、interrupted()、isInterrupted()
一，介紹
本文記錄JAVA多線程中的中斷機制的一些知識點。主要是stop方法、interrupted()與isInterrupted()方法的區別，并從源代碼的實現上進行簡單分析。
JAVA中有3種方式可以終止正在運行的線程
①線程正常退出，即run()方法執行完畢了
②使用Thread類中的stop()方法強行終止線程。但stop()方法已經過期了，不推薦使用
③使用中斷機制
線程正常退出沒有什么東東，中斷機制下面詳細介紹，先看下stop()方法的源代碼，關鍵是源代碼上的注釋。它解釋了為什么stop()不安全，stop()方法停止的是哪個線程？
/**
* Forces the thread to stop executing.
*
* If there is a security manager installed, its checkAccess
* method is called with this
* as its argument. This may result in a
* SecurityException being raised (in the current thread).
*
* If this thread is different from the current thread (that is, the current
* thread is trying to stop a thread other than itself), the
* security manager's checkPermission method (with a
* RuntimePermission("stopThread") argument) is called in
* addition.
* Again, this may result in throwing a
* SecurityException (in the current thread).
*
* The thread represented by this thread is forced to stop whatever
* it is doing abnormally and to throw a newly created
* ThreadDeath object as an exception.
*
* It is permitted to stop a thread that has not yet been started.
* If the thread is eventually started, it immediately terminates.
*
* An application should not normally try to catch
* ThreadDeath unless it must do some extraordinary
* cleanup operation (note that the throwing of
* ThreadDeath causes finally clauses of
* try statements to be executed before the thread
* officially dies). If a catch clause catches a
* ThreadDeath object, it is important to rethrow the
* object so that the thread actually dies.
*
* The top-level error handler that reacts to otherwise uncaught
* exceptions does not print out a message or otherwise notify the
* application if the uncaught exception is an instance of
* ThreadDeath.
*
* @exception SecurityException if the current thread cannot
* modify this thread.
* @see #interrupt()
* @see #checkAccess()
* @see #run()
* @see #start()
* @see ThreadDeath
* @see ThreadGroup#uncaughtException(Thread,Throwable)
* @see SecurityManager#checkAccess(Thread)
* @see SecurityManager#checkPermission
* @deprecated This method is inherently unsafe. Stopping a thread with
* Thread.stop causes it to unlock all of the monitors that it
* has locked (as a natural consequence of the unchecked
* ThreadDeath exception propagating up the stack). If
* any of the objects previously protected by these monitors were in
* an inconsistent state, the damaged objects become visible to
* other threads, potentially resulting in arbitrary behavior. Many
* uses of stop should be replaced by code that simply
* modifies some variable to indicate that the target thread should
* stop running. The target thread should check this variable
* regularly, and return from its run method in an orderly fashion
* if the variable indicates that it is to stop running. If the
* target thread waits for long periods (on a condition variable,
* for example), the interrupt method should be used to
* interrupt the wait.
* For more information, see
* Why
* are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
*/
@Deprecated
public final void stop() {
stop(new ThreadDeath());
}
上面注釋，第9行到第16行表明，stop()方法可以停止“其他線程”。執行thread.stop()方法這條語句的線程稱為當前線程，而“其他線程”則是 調用thread.stop()方法的對象thread所代表的線程。
如：
public static void main(String[] args) {
MyThread thread = new MyThread...
//.....
thread.stop();
//....
}
在main方法中，當前線程就是main線程。它執行到第4行，想把“其他線程”thread“ 給停止。這個其他線程就是MyThread類 new 的thread對象所表示的線程。
第21行至23行表明，可以停止一個尚未started(啟動)的線程。它的效果是：當該線程啟動后，就立馬結束了。
第48行以后的注釋，則深刻表明了為什么stop()方法被棄用！為什么它是不安全的。
比如說，threadA線程擁有了監視器，這些監視器負責保護某些臨界資源，比如說銀行的轉賬的金額。當正在轉賬過程中，main線程調用 threadA.stop()方法。結果導致監視器被釋放，其保護的資源(轉賬金額)很可能出現不一致性。比如，A賬戶減少了100，而B賬戶卻沒有增加100
二，中斷機制
JAVA中如何正確地使用中斷機制的細節太多了。interrupted()方法與 isInterrupted()方法都是反映當前線程的是否處于中斷狀態的。
①interrupted()
/**
* Tests whether the current thread has been interrupted. The
* interrupted status of the thread is cleared by this method. In
* other words, if this method were to be called twice in succession, the
* second call would return false (unless the current thread were
* interrupted again, after the first call had cleared its interrupted
* status and before the second call had examined it).
*
*
A thread interruption ignored because a thread was not alive
* at the time of the interrupt will be reflected by this method
* returning false.
*
* @return true if the current thread has been interrupted;
* false otherwise.
* @see #isInterrupted()
* @revised .
*/
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
從源碼的注釋中看出，它測試的是當前線程(current thread)的中斷狀態，且這個方法會清除中斷狀態。
②isInterrupted()
/**
* Tests whether this thread has been interrupted. The interrupted
* status of the thread is unaffected by this method.
*
*
A thread interruption ignored because a thread was not alive
* at the time of the interrupt will be reflected by this method
* returning false.
*
* @return true if this thread has been interrupted;
* false otherwise.
* @see #interrupted()
* @revised .
*/
public boolean isInterrupted() {
return isInterrupted(false);
}
從源碼注釋中可以看出，isInterrupted()方法不會清除中斷狀態。
③interrupted()方法與 isInterrupted()方法的區別
從源代碼可以看出，這兩個方法都是調用的isInterrupted(boolean ClearInterrupted),只不過一個帶的參數是true，另一個帶的參數是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);
因此，第一個區別就是，一個會清除中斷標識位，另一個不會清除中斷標識位。
再分析源碼，就可以看出第二個區別在return 語句上：
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
/************************/
public boolean isInterrupted() {
return isInterrupted(false);
}
interrupted()測試的是當前的線程的中斷狀態。而isInterrupted()測試的是調用該方法的對象所表示的線程。一個是靜態方法(它測試的是當前線程的中斷狀態)，一個是實例方法(它測試的是實例對象所表示的線程的中斷狀態)。
下面用個具體的例子來更進一步地闡明這個區別。
有一個自定義的線程類如下：
public class MyThread extends Thread {
@Override
public void run() {
super.run();
for (int i = ; i < ; i++) {
System.out.println("i=" + (i + ));
}
}
}
先看interrupted()方法的示例：
public class Run {
public static void main(String[] args) {
try {
MyThread thread = new MyThread();
thread.start();
Thread.sleep();
thread.interrupt();
//Thread.currentThread().interrupt();
System.out.println("是否停止？="+thread.interrupted());//false
System.out.println("是否停止？="+thread.interrupted());//false main線程沒有被中斷!!!
//......
第5行啟動thread線程，第6行使main線程睡眠1秒鐘從而使得thread線程有機會獲得CPU執行。
main線程睡眠1s鐘后，恢復執行到第7行，請求中斷 thread線程。
第9行測試線程是否處于中斷狀態，這里測試的是哪個線程呢？？？答案是main線程。因為：
(1)interrupted()測試的是當前的線程的中斷狀態
(2)main線程執行了第9行語句，故main線程是當前線程
再看isInterrupted()方法的示例：
public class Run {
public static void main(String[] args) {
try {
MyThread thread = new MyThread();
thread.start();
Thread.sleep();
thread.interrupt();
System.out.println("是否停止？="+thread.isInterrupted());//true
在第8行，是thread對象調用的isInterrupted()方法。因此，測試的是thread對象所代表的線程的中斷狀態。由于在第7行，main線程請求中斷 thread線程，故在第8行的結果為: true
總結
以上是生活随笔為你收集整理的java isinterrupted_JAVA多线程之中断机制stop()、interrupted()、isInterrupted()的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java接口注入空指针_spring 注
- 下一篇： java timer 线程安全_多线程之