本節重點說說執行緒什麼時候會阻塞，如何關閉

1 讓出時間片

Thread.yield();
通知並建議執行緒排程器，我已經做完了主要工作，時間片你可以分給別人了
即使呼叫了這個，還是可能沒有切換時間片，或者切換了，但是還是給了當前執行緒

Thread.sleep(1000);
TimeUnit.SECOND.sleep(1);
讓當前執行緒進入睡眠狀態，程式就阻塞在這裡了
這個的表現應該是比yield良好多了

但這兩個的特性，都不應該過於依賴
因為系統對時間片的劃分是不可依賴的
你的程式也不應對時間片的劃分有什麼依賴

2 任務的自我檢查

有些任務會在迴圈中檢查狀態值，如canceled之類的，會自己退出任務
但有時我們需要任務更突然的終止任務

注意：如果有標誌位canceled，isRunning等，這個一般是volatile的

private volatile boolean isFinished = false;

while(!isFinished){
    //do sth
}

如果不想用標誌位，還可以檢查是否被中斷

while(!Thread.currentThread().isInterrupted()){
    //do sth
}

3 阻塞時終止

任務除了自我檢查狀態，也可能阻塞在sleep中，此時可能也需要將其終結

執行緒的狀態：
——new：已經建立完畢，且已經start，資源分配完畢，等待分配時間片了，這個狀態只會持續很短的時間，下一步就會進入執行或者阻塞
——run：就緒狀態，只要給了時間片，就會執行，在任一時刻，thread可能執行也可能不執行
——block：阻塞狀態，程式本身能夠執行，但有個條件阻止了它執行，排程器會忽略這個執行緒，直到跳出阻塞條件，重新進入就緒狀態
——dead：run()方法返回，或者被中斷

都哪些方式可以進入block狀態：
——sleep：等時間到
——wait：等notify
——等待IO,如stream.read()
——等待synchronized鎖
——等待Lock鎖

另外，如下的大迴圈也可以interrupt
while(!Thread.currentThread().isInterrupted()){
    ThreadLocalVariableHolder.increment();
    System.out.println(this);
    Thread.yield();
}

終結情形1：

//注意isCanceled是個boolean，而且一般會需要volatile修飾
 

public void run(){
    while(!isCanceled){
        //do some seriers work
    }
}

終結情形2：

//thread.interrupt()可以打斷
//Executors得不到thread的引用，只能通過ExecutorService.shutdownNow()來打斷
//如果能拿到Future，可以Future.cancel(true)來打斷
//exec.execute(Runnable)看來是打斷不了了，因為拿不到什麼引用
//exec.submit()，還是能打斷的，返回了Future
//本質上都是呼叫了thread.interrupt()

關於shutdown：
shutdown()：拒絕再接收新的task，但已有的task會執行到terminate  
shutdownNow()：禁止再接收新的task，已有task，在waiting的不會再start，已經執行的會嘗試stop掉  

未shutdown狀態：執行緒池還在執行，不管有沒有running，waiting的task，都會一直等待add新task（通過execute或者submit）  
shutdown狀態：執行完現有task，就會terminate

public void run(){
    while(!Thread.currentThread().isInterrupt()){   //或者用Thread.interrupted()判斷
        //do some seriers work
    }
}

public void run(){
    while(true){
        Thread.sleep(1000); 
        //被interrupt會丟擲異常，因為既然是阻塞，被意外終止，異常看似挺合理
        //do some seriers work
    }
}

終結情形3：終結不了的synchronized

在等待synchronized的執行緒，不可以被interrupt
但是注意，Lock可以嘗試獲取鎖，並可以指定阻塞等待鎖的時間限制

終結情形4：ReentrantLock.lockInterruptly()

ReentrantLock.lockInterruptly()，在這裡獲取不到鎖，會阻塞，但是可以被interrupt方法中斷

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

class BlockedMutex {
  private Lock lock = new ReentrantLock();
  public BlockedMutex() {
    // Acquire it right away, to demonstrate interruption
    // of a task blocked on a ReentrantLock:
    lock.lock();
  }
  public void f() {
    try {
      // This will never be available to a second task
      lock.lockInterruptibly(); // Special call
      System.out.println("f()方法得到鎖了？？");
    } catch(InterruptedException e) {
      System.out.println("f()方法沒得到鎖，而是被中斷了，被interrupt了");
    }
  }
}

class Blocked2 implements Runnable {
  BlockedMutex blocked = new BlockedMutex();
  public void run() {
    System.out.println("等f()拿到ReentranLock");
    blocked.f();
    System.out.println("從f()返回了");
  }
}

public class Interrupting2 {
  public static void main(String[] args) throws Exception {
    Thread t = new Thread(new Blocked2());
    t.start();
    TimeUnit.SECONDS.sleep(1);
    System.out.println("呼叫了t.interrupt()");
    t.interrupt();
  }
} /* Output:
Waiting for f() in BlockedMutex
Issuing t.interrupt()
Interrupted from lock acquisition in f()
Broken out of blocked call
*///:~

終結情形5：IO密集型阻塞

在等待InputStream.read()的執行緒，不可以被interrupt
但是有個笨辦法：關閉執行緒正在等待的底層IO資源，如關閉Socket
還有個更好的選擇：nio，提供了更人性化的中斷，被阻塞的nio通道會自動響應中斷

4 例項

無法被打斷的例子

public static void main(String[] args) throws InterruptedException {
    Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            while(true){
                System.out.println("go on...");
            }
        }
    });

    t.start();

    Thread.sleep(2000);
    t.interrupt();

    while(true){
        Thread.yield();
    }
}

如果一個Runnable沒有cancel類的標誌位檢查，也沒有檢查isInterrupt()，呼叫interrupt()會怎麼地？  
是關不掉的，但這種形式的無限迴圈，一般不會出現在真實場景裡
真實場景什麼樣？一般是一個無限迴圈，但裡面會阻塞（等待條件成熟），有跳出條件  

處理InterrupttedException

執行緒被中斷之後，會發異常InterrupttedException，有時需要清理資源，參考類c10.InterruptingIdiom

class NeedsCleanup {
  private final int id;
  public NeedsCleanup(int ident) {
    id = ident;
    System.out.println("NeedsCleanup " + id);
  }
  public void cleanup() {
    System.out.println("Cleaning up " + id);
  }
}

class Blocked3 implements Runnable {
  private volatile double d = 0.0;
  public void run() {
    try {
      while(!Thread.interrupted()) {
        // point1
        NeedsCleanup n1 = new NeedsCleanup(1);
        // Start try-finally immediately after definition
        // of n1, to guarantee proper cleanup of n1:
        try {
          System.out.println("Sleeping");
          TimeUnit.SECONDS.sleep(1);
          // point2
          NeedsCleanup n2 = new NeedsCleanup(2);
          // Guarantee proper cleanup of n2:
          try {
            System.out.println("Calculating");
            // A time-consuming, non-blocking operation:
            for(int i = 1; i < 2500000; i++)
              d = d + (Math.PI + Math.E) / d;
            System.out.println("Finished time-consuming operation");
          } finally {
            n2.cleanup();
          }
        } finally {
          n1.cleanup();
        }
      }
      System.out.println("Exiting via while() test");
    } catch(InterruptedException e) {
      System.out.println("Exiting via InterruptedException");
    }
  }
}

public class InterruptingIdiom {
  public static void main(String[] args) throws Exception {
    long delay = 2000;
    Thread t = new Thread(new Blocked3());
    t.start();
    TimeUnit.MILLISECONDS.sleep(delay);
    t.interrupt();
  }
} /* Output: (Sample)
NeedsCleanup 1
Sleeping
NeedsCleanup 2
Calculating
Finished time-consuming operation
Cleaning up 2
Cleaning up 1
NeedsCleanup 1
Sleeping
Cleaning up 1
Exiting via InterruptedException
*///:~