Java執行緒狀態和關閉執行緒的正確姿勢

  • 2019 年 10 月 17 日
  • 筆記

1、執行緒狀態及切換

　　Java中的執行緒有六種狀態，使用執行緒Thread內的枚舉類來實現，如下，我對每個狀態都進行了一定的解釋。

　　public enum State {          /** 表示一個執行緒還沒啟用（即未調用start方法）*/          NEW,            /**           * JVM中執行的執行緒都是處於這個狀態的，但是處於這個狀態不一定在JVM中執行，           * 也就是說，只有這個狀態有資格被JVM調度從而獲得時間片執行。           */          RUNNABLE,            /**           * 執行緒在等待獲取鎖資源從而進入阻塞狀態，           * 在這個狀態中，其一直監視鎖的動態，隨時準備搶佔鎖           * 若獲得鎖資源，重新進入RUNNABLE狀態           */          BLOCKED,            /**           * 當調用Object.wait、Thread.join或者LockSupport類的park方法的時候，執行緒進入此狀態，           * 該狀態若無其他執行緒主動喚醒，則無期限的等待。           * 喚醒的方法包括：Object.notify（喚醒隨機一個）、Object.notifyAll（喚醒全部執行緒），           * 被喚醒的執行緒重新進入RUNNABLE狀態           */          WAITING,            /**           * 同WAITING狀態，不過不同的是調用的方法加上了時間的限制，           * 例如：Object.wait(10)、Thread.sleep(10)、Thread.join(10)、LockSupport.parkNanos(10)、LockSupport.parkUntil(10)這些方法           * 喚醒的方法有兩種：           *     1、時間過期。           *     2、其他執行緒調用了notify或者notifyAll           *  喚醒之後同樣進入RUNNABLE狀態           */          TIMED_WAITING,            /** 執行緒的終點（正常死亡或者被終止）*/          TERMINATED;      }

 　　除了NEW和TERMINATED之外，其他的狀態都是可以相互轉換的，其轉換過程如下圖所示

 

　　這裡特別講一下RUNNABLE狀態，在這個狀態中執行緒並不一定在執行程式，只有被JVM調度的執行緒才能獲得執行的時間片，並且只有這個狀態的執行緒才能夠獲得時間片，換句話說，被JVM調度並且獲得時間片是只屬於處於RUNNABLE狀態執行緒的權利。為了便於理解，可以將RUNNABLE分成Runnable和Running兩個狀態（當然，你也可以換成其他的，這裡我只是自己好理解），那麼上面的執行緒轉換圖就轉變成了下面這樣（參考《Java並發編程的藝術》中的執行緒狀態圖）：

 

 　　關於執行緒狀態轉換的例子，可以通過下面的程式碼加深理解

public class Test {      public static void main(String[] args) {          Test test = new Test();          // 1.NEW狀態          Thread thread = new Thread(() -> {              // 3.進行test對象鎖的爭奪，若搶到鎖則繼續執行，否則進入BLOCKED狀態監控該鎖，重新獲得後進入RUNNABLE               synchronized (test) {                  try {                      // 4.進入TIMED_WAITING狀態，100ms後重新進入RUNNABLE狀態爭奪時間片                       Thread.sleep(100);                      // 5.重新獲得時間片之後，進入WAITING狀態                       test.wait();                  } catch (InterruptedException e) {                      e.printStackTrace();                  }              }              // 6.正常run()方法執行完畢後執行緒結束，進入TERMINATED           });          // 2.調用start()方法，執行緒進入RUNNABLE狀態          thread.start();      }
}

註：程式碼執行的順序為注釋的序號

 2、正確的結束一個執行緒

　　在上面的例子中我們看到執行緒的run方法正常執行完畢之後執行緒就正常死亡進入TERMINATED狀態了，那麼如果我們有中途停止執行緒的需求，我們應該如何正確的結束一個執行緒呢？

  1. 使用interrupt()方法：在執行緒內部，其定義了一個變數來標識當前執行緒是否處於被打斷狀態，調用interrupt()方法則使這個狀態變為true。我們採用這個方法加異常處理的方式來結束一個執行緒。 
    　　public static void main(String[] args) {          Thread thread = new Thread(() -> {              try {                  Thread.sleep(1);              } catch (InterruptedException e) {                  e.printStackTrace();                  // 這裡的return是必須的，原因後面說明                  return;              }              System.err.println("thread interrupt test...");          });          thread.start();          thread.interrupt();          System.out.println("main thread end...");      }

    // 結果圖：異常後面的語句不會列印


    　　這裡關於執行緒中的打斷標識變數（之後以interrupt稱）需要說明的是，在特定的情況下其狀態會被重置。
    　　    1、執行緒內部在catch了異常了之後interrupt的狀態會被重置為false。
           2、執行緒調用了Thread.interrupted()方法之後，interrupt的狀態會被重置為false。如果需要判斷執行緒是否中斷的話可以使用對象方法isInterrupted()，此方法不會重置。
       所以在剛才的程式碼中需要加入return來結束執行緒，否則的話執行緒還是會繼續往下執行，如下圖


    使用isInterrupted()實現：
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                int k = 0;
                while (k++ < 10) {
                    System.out.println("do something..." + k);
                }
            }
        System.err.println("thread end...");
        });
        thread.start();
        Thread.sleep(1);
        // 主執行緒流程執行完了，需要停止執行緒
        thread.interrupt();
    }

     　

  2. 使用標識位來實現：定義一個變數標識執行緒是否終止，若終止了則退出run方法。跟上面isInterrupted()的實現一樣，不過換成了volatile變數而已。 
    public class Test {        public static volatile boolean interrupted = false;        public static void main(String[] args) throws InterruptedException {          Thread thread = new Thread(() -> {              while (!interrupted) {                  int k = 0;                  while (k++ < 10) {                      if (interrupted) {                          System.err.println("thread invoke end....");                          return;                      }                      System.out.println("do something..." + k);                  }              }          System.err.println("thread end...");          });          thread.start();          Thread.sleep(1);          // 主執行緒流程執行完了，需要停止執行緒          interrupted = true;      }  }
    // 結果圖

     

　stop()方法——不正確的執行緒中斷方法

　　  在執行緒提供的方法中還有一個方法可以強制關閉執行緒——stop()。這個方法可以說是相當的霸道，給人一種“我不管，我就是要你現在立刻死亡（指執行緒）”的感覺，並且其還會釋放執行緒所有的鎖資源，這樣可能會導致出現數據不一致從而出現執行緒不安全的情況，如下面例子。

public class Test {            public static volatile boolean flag = false;          public int state = 0;            public static void main(String[] args) throws InterruptedException {              Test test = new Test();              Thread thread = new Thread(() -> {                  synchronized (test) {                      try {                          test.state = 1;                          Thread.sleep(100);                          if (flag) {                              test.state = 2;                          }                          System.err.println("thread execute finished...");                      } catch (InterruptedException e) {                          e.printStackTrace();                      }                  }              });              thread.start();              Thread.sleep(1);              thread.stop();              flag = true;              System.out.println("state狀態：" + test.state);          }  }
// 在這段程式碼中，進入執行緒時默認將state賦為1，接著過一段時間後如果觸發了特定條件則把state賦為2，但是在特定條件觸發之前，執行緒就被終止掉了，這個特定條件雖然符合但卻沒辦法執行，從而導致數據的不一致。
// 結果圖
　　


　　所以，我們應該採用上面兩種正確的方式而不是stop()來中止執行緒。此外，stop()方法若在執行緒start()之前執行，那麼在執行緒啟動的時候就會立即死亡。

 

 

若有不對之處，望各位不吝指教（反正免費，對吧）。

VirMach 便宜 VPS

QNews

QNews