1. 程式人生 > >java中執行緒池的生命週期

java中執行緒池的生命週期

執行緒池生命週期包括:

  • RUNNING:接收新的任務並處理佇列中的任務
  • SHUTDOWN:不接收新的任務,但是處理佇列中的任務
  • STOP:不接收新的任務,不處理佇列中的任務,同時中斷處理中的任務
  • TIDYING:所有的任務處理完成,有效的執行緒數是0
  • TERMINATED:terminated()方法執行完畢

轉換成TIDYING狀態的執行緒會執行terminated方法。執行完terminated()方法之後,所有等待在awaitTermination()就會返回。

轉換過程為:

執行緒池是空的即有效執行緒數是0

取消

如果程式碼能夠在某個操作正常完全之前置入“完成”狀態,那麼這個操作就稱為可取消的。java中提供了協作式機制,使請求取消的任務和程式碼遵循一種協商好的協議。

執行緒中斷

執行緒中斷就是一種協作機制。它並不會真正的中斷一個正在執行的執行緒,而只是發出中斷請求,然後由執行緒在下一個合適的時刻中斷自己。
Thread中的中斷方法包括

interrupt

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();//非當前執行緒有可能丟擲SecurityException

    synchronized (blockerLock) {
        //用於執行可終端的IO操作對應的方法
        Interruptible b = blocker;
        if
(b != null) { //僅設定終端標記 interrupt0(); //執行實現了Interruptible介面的防範 b.interrupt(this); return; } } //僅設定終端標記 interrupt0(); } 複製程式碼

呼叫它根據執行緒的不同場景,有不同的結果

  1. 如果執行緒阻塞的是一個可以終端的channel,那麼channel會被關閉,同時執行緒會收到java.nio.channels.ClosedByInterruptException,並且會設定中斷標誌

    //AbstractInterruptibleChannel中:
    protected final void begin() {
            if (interruptor == null) {
                interruptor = new Interruptible() {
                        public void interrupt(Thread target) {
                            synchronized (closeLock) {
                                if (!open)
                                    return;
                                open = false;
                                interrupted = target;
                                try {
                                //關閉channel
                                AbstractInterruptibleChannel.this.implCloseChannel();
                                } catch (IOException x) { }
                            }
                        }};
            }
            blockedOn(interruptor);
            Thread me = Thread.currentThread();
            if (me.isInterrupted())
                interruptor.interrupt(me);
        }
    複製程式碼
  2. 如果執行緒阻塞在Selector,執行它的 wakeup方法,因而selector會立即返回,同時會設定中斷標誌

    //AbstractSelector中:
    protected final void begin() {
        if (interruptor == null) {
            interruptor = new Interruptible() {
                    public void interrupt(Thread ignore) {
                        //執行wakeup,Selector立即返回
                        AbstractSelector.this.wakeup();
                    }};
        }
        AbstractInterruptibleChannel.blockedOn(interruptor);
        Thread me = Thread.currentThread();
        if (me.isInterrupted())
            interruptor.interrupt(me);
    }
    複製程式碼
  3. 如果執行緒阻塞在wait/join/sleep,執行緒的中斷標誌會被清除,並丟擲InterruptedException

  4. 非上述三種情況,僅設定中斷標誌

可以看出呼叫interrupt並不意味著立即停止目標執行緒正在進行的工作,而只是傳遞了請求中斷的訊息

interrupted

清除當前執行緒的中斷狀態,並返回之前的值。它實際執行的就是當前執行緒的isInterrupted(true)

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
複製程式碼

假設當前執行緒是中斷的,此時呼叫會返回true,如果在下次呼叫之前沒有中斷,此時呼叫會返回false

isInterrupted

返回目標執行緒的中斷狀態,只有執行緒狀態是中斷才會返回true,其它時候返回false

public boolean isInterrupted() {
    return isInterrupted(false);
}
複製程式碼

可以看到interrupted和isInterrupted 呼叫的都是isInterrupted方法,只不過引數不一樣。它的引數實際代表的是是否要清除中斷標記,為true也就清除,在java中的定義如下

private native boolean isInterrupted(boolean ClearInterrupted);
複製程式碼
參考linux上的實現為
```
bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
    "possibility of dangling Thread pointer");

  OSThread* osthread = thread->osthread();

  bool interrupted = osthread->interrupted();

  if (interrupted && clear_interrupted) {
    osthread->set_interrupted(false); //如果中斷了,並且要清除中斷標記,就改變終端標記
    // consider thread->_SleepEvent->reset() ... optional optimization
  }

  return interrupted;
}
```
複製程式碼

響應中斷 - 處理InterruptedException

一般策略如下

  • 傳遞異常,使當前方法也成為可中斷的
  • 恢復中斷狀態,使得呼叫棧中的上層程式碼能夠對其進行處理

處理不可中斷的阻塞

並非所有的可阻塞方法或者阻塞機制都能響應中斷,停止執行緒的方法類似於中斷

  • Java.io中的Socket I/O。InputStream和OutputStream中的read和write等不會響應中斷,可以關閉底層的套接字丟擲SocketException
  • Java.io中的同步I/O。大多數的標準的channel都實現了InterruptibleChannel,它內部一般都是丟擲ClosedByInterruptException,並關閉鏈路
  • Selector的非同步I/O。阻塞在了Selector.select,通過呼叫wakeup或者close來提前返回。
  • 獲取某個鎖。由於執行緒等待某個內建鎖,它會認為自己能等到,所以不會處理中斷,通過Lock的lockInterruptibly可以同時實現等待鎖並且響應中斷

Thread.stop本身是不安全的。停止一個執行緒會釋放它所有的鎖的監視器,如果有任何一個受這些監視器保護的物件出現了狀態不一致,其它的執行緒也會以不一致的狀態檢視這個物件,其它執行緒在這個物件上的任何操作都是無法預料的 為什麼廢棄了Thread.stop

關閉

應用程式準備退出時,這些服務所擁有的執行緒也應該結束。 ExecutorService提供了兩種方法:shutdown和shutdownNow

  • shutdown在執行完佇列中的所有任務之後,才關閉,它並不會接收新的任務
  • shutdownNow則是立馬關閉正在執行的任務,並返回還沒有開始的任務