詳細介紹ThreadPoolExecutor的方法：

• 方法shutdown() 和 shutdownNow()

    shutdown ：使當前未執行的執行緒繼續執行，而不再新增新的任務Task，該方法不會阻塞。

    shutdownNow ：    

  1.  當在Runnable中使用 if(Thread.currentThread.isInterruptd() == true)來判斷當前執行緒的中斷狀態，，中斷所有的任務task，並且丟擲InterruptedException異常，而未執行的執行緒不再執行，從任務佇列中清除。  

  2.  如果沒有if語句，則池中執行的執行緒直到執行完畢，而未執行的不再執行，從執行佇列佇列中刪除。

區別： 

        池子呼叫shutdown，池中狀態立馬變成SHUTDOWN狀態，此時再往池中新增任務，會觸發拒絕策略。此時池中不會立刻退出，直到池中的任務都已經完成，才會退出。

        總之：呼叫後，正在執行的任務和佇列中的任務在後期正常執行，只是不再添加了。

        池子呼叫shutdownNow，池中狀態立馬變成STOP狀態，並試圖停止所有正在執行的執行緒（除非有if判斷人為的丟擲異常），不再處理還在池佇列中等待的任務，會返還未執行的任務。

        總之：呼叫，停止正在執行的，用一個llist<Runnable>佇列來儲存未執行的任務，並返回。

• isShutdown()

      判斷執行緒池是否已經關閉，只要呼叫的shutdown()方法，則isShutdown()方法的返回值就是true。，

• isTerminating() 和 isTerminated()

     前者是否正在關閉，但尚未完全終止的過程，返回true。

     後者是已經關閉了。

• awaitTermination(long timeout, TimeUnit unit)

     檢視在指定的時間內，池子是否已經終止工作，即最多等待多少時間後去判斷池子已經終止工作。

     一般和shutdown()方法配合

      如果池中有任務在被執行時，呼叫其方法會出現阻塞，等待指定的時間，如果沒有任務則不會出現阻塞。

所以這個方法和shutdown結合可以實現“等待執行完畢”的效果，就是因為其有阻塞性。

       如果正在阻塞的時候，任務執行完畢，那麼該會取消阻塞繼續執行後面的程式碼。

public class test{
    public static void main(String[] args) throws InterruptedException{
        MyRunnable myrunnable = new MyRunnable();
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,9999,9999L,
                TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        pool.execute(myrunnable);
        pool.shutdown();
        System.out.println("begin");
        // 阻塞10s(等待10s),如果改成1s，則是false，在4s之前就已經停止判斷了
        System.out.println(pool.awaitTermination(10,TimeUnit.SECONDS));
        System.out.println("end");
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        try{
            System.out.println(Thread.currentThread().getName()+ " " + System.currentTimeMillis());
            Thread.sleep(4000);   //睡眠4秒
            System.out.println(Thread.currentThread().getName()+ " " + System.currentTimeMillis());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

// 正在阻塞時，任務執行完畢，那麼會取消阻塞
public class test{
    public static void main(String[] args) throws InterruptedException{
        MyRunnable myrunnable = new MyRunnable();
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,9999,9999L,
                TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        pool.execute(myrunnable);
        pool.execute(myrunnable);
        pool.execute(myrunnable);
        pool.execute(myrunnable);
        pool.shutdown();
        System.out.println(pool.awaitTermination(Integer.MAX_VALUE,
                TimeUnit.SECONDS)+ " " + System.currentTimeMillis()+ "全部執行完畢");
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        try{
            System.out.println(Thread.currentThread().getName() + " "
                + System.currentTimeMillis());
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

• setThreadFactory方法+UncaughtExceptionHandler處理異常

    對執行緒池建立的執行緒進行屬性定製化，當程式丟擲異常時，可以自定義處理。

    除了用構造方法來傳遞自定義ThreadFactory外，還可以使用setThreadFactory來設定自定義的執行緒工廠。

public class Test{
    public static void main(String[] args) {
      MyThreadFactory mythreadFactory = new MyThreadFactory();
      MyRunnable myrunnable = new MyRunnable();
      ThreadPoolExecutor pool = new ThreadPoolExecutor(2,9999,9999L, 
              TimeUnit.SECONDS, new LinkedBlockingDeque<>(),mythreadFactory); 
         // 利用構造引數來傳入自定義的執行緒工廠
        // pool.setThreadFactory(mythreadFactory); 完全可以用方法來傳入自定義執行緒工廠
      pool.execute(myrunnable);
    }}

class MyRunnable implements Runnable和上述一樣

class MyThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
       Thread newthread = new Thread(r);
       newthread.setName("wang" + new Date());  // 自定義工廠，如果出現異常是可以自定義處理的。
       newthread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
          @Override
          public void uncaughtException(Thread t, Throwable e) {
                System.out.println("自定義處理異常" + t.getName() + e.getMessage());
                e.printStackTrace();
            }
        });
        return newthread;
    }}

• set/getRejectExecutionHandler()
      可以處理任務被拒絕執行時的行動

public class Test{
    public static void main(String[] args) {
        MyRunnable myRunnable1 = new MyRunnable("wang1");
        MyRunnable myRunnable2 = new MyRunnable("wang2");
        MyRunnable myRunnable3 = new MyRunnable("wang3");
        MyRunnable myRunnable4 = new MyRunnable("wang4");

        //是直接提交的排隊策略，最大3個顯然會有一個拒絕
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,9999L,
                TimeUnit.SECONDS, new SynchronousQueue<>());
        pool.setRejectedExecutionHandler(new MyRejectExecutionhandle());   //實現自定義拒絕策略
        pool.execute(myRunnable1);
        pool.execute(myRunnable2);
        pool.execute(myRunnable3);
        pool.execute(myRunnable4);
    }
}

class MyRejectExecutionhandle implements RejectedExecutionHandler{

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println(((MyRunnable)r).getUsername() + "被拒絕了");
    }
}

class  MyRunnable implements Runnable{

 private String username;
 public MyRunnable(String username){      
    super();
    this.username = username;
 }
 public String getUsername(){return username;}
 public void setUsername(String username){
     this.username = username;
 }
 @Override
 public void run() {
    try{
         System.out.println(Thread.currentThread().getName()+ " " + System.currentTimeMillis());
         Thread.sleep(4000);   //睡眠4秒
         System.out.println(Thread.currentThread().getName()+ " " + System.currentTimeMillis());
     }catch (InterruptedException e){
         e.printStackTrace();
     }
 }
}

• prestartCoreThread() 和 prestartAllCoreThreads()
  前者每次呼叫一次就建立一個核心執行緒，返回的是boolean
  後者啟動全部核心執行緒，返回的是啟動核心執行緒的數量
• remove（Runnable）
  可以刪除尚未被執行的Runnable任務。
• 多個get方法
  getActiveCount() : 取得多少個執行緒正在執行的任務
  getPoolSize() : 當前池中裡面有多少個執行緒，包括正在執行任務的執行緒，也包括在休眠的執行緒
  getCompletedTaskCount() ：取得已經執行完成的任務數
  getCorePoolSize() : 取的構造方法傳入的corePoolSize引數值
  getMaximumPoolSize() : 取的構造方法中MaximumPoolSize的引數值
  getPoolSize() : 取的池中有多少個執行緒
  getTaskCount() ： 取得有多少個任務傳送給了執行緒池，執行的+ 排隊的
  
  

有一點要注意： 介面Runnable在ThreadPooExecutor佇列中是按順序取出的，執行卻是亂序的。