Java併發編程（3）：線程掛起、恢復與終止的正確方法（含代碼）

掛起和恢復線程

Thread 的API中包含兩個被淘汰的方法，它們用於臨時掛起和重啓某個線程，這些方法已經被淘汰，由於它們是不安全的，不穩定的。若是在不合適的時候掛起線程（好比，鎖定共享資源時），此時即可能會發生死鎖條件——其餘線程在等待該線程釋放鎖，但該線程卻被掛起了，便會發生死鎖。另外，在長時間計算期間掛起線程也可能致使問題。

下面的代碼演示了經過休眠來延緩運行，模擬長時間運行的狀況，使線程更可能在不適當的時候被掛起：

 

public class DeprecatedSuspendResume extends Object implements Runnable{
 
 //volatile關鍵字，表示該變量可能在被一個線程使用的同時，被另外一個線程修改
 private volatile int firstVal;
 private volatile int secondVal;
 
 //判斷兩者是否相等
 public boolean areValuesEqual(){
 return ( firstVal == secondVal);
 }
 
 public void run() {
 try{
 firstVal = 0;
 secondVal = 0;
 workMethod();
 }catch(InterruptedException x){
 System.out.println("interrupted while in workMethod()");
 }
 }
 
 private void workMethod() throws InterruptedException {
 int val = 1;
 while (true){
 stepOne(val);
 stepTwo(val);
 val++;
 Thread.sleep(200); //再次循環錢休眠200毫秒
 }
 }
 
 //賦值後，休眠300毫秒，從而使線程有機會在stepOne操做和stepTwo操做之間被掛起
 private void stepOne(int newVal) throws InterruptedException{
 firstVal = newVal;
 Thread.sleep(300); //模擬長時間運行的狀況
 }
 
 private void stepTwo(int newVal){
 secondVal = newVal;
 }
 
 public static void main(String[] args){
 DeprecatedSuspendResume dsr = new DeprecatedSuspendResume();
 Thread t = new Thread(dsr);
 t.start();
 
 //休眠1秒，讓其餘線程有機會得到執行
 try {
 Thread.sleep(1000);} 
 catch(InterruptedException x){}
 for (int i = 0; i < 10; i++){
 //掛起線程
 t.suspend();
 System.out.println("dsr.areValuesEqual()=" + dsr.areValuesEqual());
 //恢復線程
 t.resume();
 try{ 
 //線程隨機休眠0~2秒
 Thread.sleep((long)(Math.random()*2000.0));
 }catch(InterruptedException x){
 //略
 }
 }
 System.exit(0); //中斷應用程序
 }
}

某次運行結果以下：

從areValuesEqual（）返回的值有時爲true，有時爲false。以上代碼中，在設置firstVal以後，但在設置secondVal以前，掛起新線程會產生麻煩，此時輸出的結果會爲false（狀況1），這段時間不適宜掛起線程，但由於線程不能控制什麼時候調用它的suspend方法，因此這種狀況是不可避免的。

固然，即便線程不被掛起（註釋掉掛起和恢復線程的兩行代碼），若是在main線程中執行asr.areValuesEqual（）進行比較時，恰逢stepOne操做執行完，而stepTwo操做還沒執行，那麼獲得的結果一樣多是false（狀況2）。

下面咱們給出不用上述兩個方法來實現線程掛起和恢復的策略——設置標誌位。經過該方法實現線程的掛起和恢復有一個很好的地方，就是能夠在線程的指定位置實現線程的掛起和恢復，而不用擔憂其不肯定性。

對於上述代碼的改進代碼以下：

 

public class AlternateSuspendResume extends Object implements Runnable {
 
 private volatile int firstVal;
 private volatile int secondVal;
 //增長標誌位，用來實現線程的掛起和恢復
 private volatile boolean suspended;
 
 public boolean areValuesEqual() {
 return ( firstVal == secondVal );
 }
 
 public void run() {
 try {
 suspended = false;
 firstVal = 0;
 secondVal = 0;
 workMethod();
 } catch ( InterruptedException x ) {
 System.out.println("interrupted while in workMethod()");
 }
 }
 
 private void workMethod() throws InterruptedException {
 int val = 1;
 
 while ( true ) {
 //僅當賢臣掛起時，才運行這行代碼
 waitWhileSuspended(); 
 
 stepOne(val);
 stepTwo(val);
 val++;
 
 //僅當線程掛起時，才運行這行代碼
 waitWhileSuspended(); 
 
 Thread.sleep(200); 
 }
 }
 
 private void stepOne(int newVal) 
 throws InterruptedException {
 
 firstVal = newVal;
 Thread.sleep(300); 
 }
 
 private void stepTwo(int newVal) {
 secondVal = newVal;
 }
 
 public void suspendRequest() {
 suspended = true;
 }
 
 public void resumeRequest() {
 suspended = false;
 }
 
 private void waitWhileSuspended() 
 throws InterruptedException {
 
 //這是一個「繁忙等待」技術的示例。
 //它是非等待條件改變的最佳途徑，由於它會不斷請求處理器週期地執行檢查， 
 //更佳的技術是：使用Java的內置「通知-等待」機制
 while ( suspended ) {
 Thread.sleep(200);
 }
 }
 
 public static void main(String[] args) {
 AlternateSuspendResume asr = 
 new AlternateSuspendResume();
 
 Thread t = new Thread(asr);
 t.start();
 
 //休眠1秒，讓其餘線程有機會得到執行
 try { Thread.sleep(1000); } 
 catch ( InterruptedException x ) { }
 
 for ( int i = 0; i < 10; i++ ) {
 asr.suspendRequest();
 
 //讓線程有機會注意到掛起請求
 //注意：這裏休眠時間必定要大於
 //stepOne操做對firstVal賦值後的休眠時間，即300ms，
 //目的是爲了防止在執行asr.areValuesEqual（）進行比較時,
 //恰逢stepOne操做執行完，而stepTwo操做還沒執行
 try { Thread.sleep(350); } 
 catch ( InterruptedException x ) { }
 
 System.out.println("dsr.areValuesEqual()=" + 
 asr.areValuesEqual());
 
 asr.resumeRequest();
 
 try { 
 //線程隨機休眠0~2秒
 Thread.sleep(
 ( long ) (Math.random() * 2000.0) );
 } catch ( InterruptedException x ) {
 //略
 }
 }
 
 System.exit(0); //退出應用程序
 }
}

運行結果以下：

由結果能夠看出，輸出的全部結果均爲true。首先，針對狀況1（線程掛起的位置不肯定），這裏肯定了線程掛起的位置，不會出現線程在stepOne操做和stepTwo操做之間掛起的狀況；針對狀況2（main線程中執行asr.areValuesEqual（）進行比較時，恰逢stepOne操做執行完，而stepTwo操做還沒執行），在發出掛起請求後，尚未執行asr.areValuesEqual（）操做前，讓main線程休眠450ms（>300ms），若是掛起請求發出時，新線程正執行到或即將執行到stepOne操做（若是在其前面的話，就會響應掛起請求，從而掛起線程），那麼在stepTwo操做執行前，main線程的休眠還沒結束，從而main線程休眠結束後執行asr.areValuesEqual（）操做進行比較時，stepTwo操做已經執行完，所以也不會出現輸出結果爲false的狀況。

能夠將ars.suspendRequest（）代碼後的sleep代碼去掉，或將休眠時間改成200（明顯小於300便可）後，查看執行結果，會發現結果中依然會有出現false的狀況。以下圖所示：

總結：線程的掛起和恢復實現的正確方法是：經過設置標誌位，讓線程在安全的位置掛起

終止線程

當調用Thread的start（）方法，執行完run（）方法後，或在run（）方法中return，線程便會天然消亡。另外Thread API中包含了一個stop（）方法，能夠忽然終止線程。但它在JDK1.2後便被淘汰了，由於它可能致使數據對象的崩潰。一個問題是，當線程終止時，不多有機會執行清理工做；另外一個問題是，當在某個線程上調用stop（）方法時，線程釋放它當前持有的全部鎖，持有這些鎖一定有某種合適的理由——也許是阻止其餘線程訪問還沒有處於一致性狀態的數據，忽然釋放鎖可能使某些對象中的數據處於不一致狀態，並且不會出現數據可能崩潰的任何警告。

終止線程的替代方法：一樣是使用標誌位，經過控制標誌位來終止線程。

歡迎工做一到五年的Java工程師朋友們加入Java架構開發 ： 867748702 羣內提供免費的Java架構學習資料（裏面有高可用、高併發、高性能及分佈式、 Jvm性能調優、Spring源碼，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper, Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料） 合理利用本身每一分每一秒的時間來學習提高本身， 不要再用"沒有時間「來掩飾本身思想上的懶惰！趁年輕，使勁拼，給將來的本身一個交代！