Java 線程池異步任務

一、簡單粗暴的線程

　　最原始的方式，當我們要並行的或者異步的執行一個任務的時候，我們會直接使用啟動一個線程的方式，如下面所示：

new Thread(new Runnable() {

    @Override
   public void run() {
       // TODO Auto-generated method stub  這裡放你要執行的方法
    }
}).start(); 

　　但是像上面或者類似這種每次來都是用new 一個Thread出來的方式存在著很多的弊端，如下面：

• 每次new Thread新建對象性能差；
• 線程缺乏統一的管理，可以無限制新建線程，相互之間競爭，還可能占用過多系統資源導致死機或者OOM(Out of Memory)；
• 缺乏更多的功能，如定時執行、定期執行、線程中斷等。

二、線程池

　　為了解決這些問題，Jdk1.5之後加入了java.util.concurrent包，這個包中主要介紹java中線程以及線程池的使用。為我們在開發中處理線程的問題提供了非常大的幫助。

1、作用

　　根據系統的環境情況，可以自動或手動設置線程數量，達到運行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用線程池控制線程數量，其他線程排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程，線程池的這一資源處於等待。當一個新任務需要運行時，如果線程池中有等待的工作線程，就可以開始運行了；否則進入等待隊列。

2、為什麼要用線程池

• 重用存在的線程，減少對象創建、消亡的開銷，性能佳。
• 可有效控制最大並發線程數，提高系統資源的使用率，同時避免過多資源競爭，避免堵塞。
• 提供定時執行、定期執行、單線程、並發數控制等功能。
• 可以根據系統的承受能力，調整線程池中工作線線程的數目，防止因為消耗過多的內存，而把服務器累趴下(每個線程需要大約1MB內存，線程開的越多，消耗的內存也就越大，最後死機)。

 3、主要的類

　　Java裡面線程池的頂級接口是Executor，但是嚴格意義上講Executor並不是一個線程池，而只是一個執行線程的工具。真正的線程池接口是ExecutorService。

ExecutorService

真正的線程池接口。

ScheduledExecutorService

能和Timer/TimerTask類似，解決那些需要任務重復執行的問題。

ThreadPoolExecutor

ExecutorService的默認實現。

ScheduledThreadPoolExecutor

繼承ThreadPoolExecutor的ScheduledExecutorService接口實現，周期性任務調度的類實現。

　　要配置一個線程池是比較復雜的，尤其是對於線程池的原理不是很清楚的情況下，很有可能配置的線程池不是較優的，因此在Executors類裡面提供了一些靜態工廠，生成一些常用的線程池。

1）newSingleThreadExecutor

　　創建一個單線程的線程池。這個線程池只有一個線程在工作，也就是相當於單線程串行執行所有任務。如果這個唯一的線程因為異常結束，那麼會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。

2）newFixedThreadPool

　　創建固定大小的線程池。每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因為執行異常而結束，那麼線程池會補充一個新線程。

3）newCachedThreadPool

　　創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程，

　　那麼就會回收部分空閒（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴於操作系統（或者說JVM）能夠創建的最大線程大小。

4）newScheduledThreadPool

　　創建一個大小無限的線程池。此線程池支持定時以及周期性執行任務的需求。

三、實例

 1）newCachedThreadPool
　　創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   try {
    Thread.sleep(index * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   cachedThreadPool.execute(new Runnable() {
    public void run() {
     System.out.println(index);
    }
   });
  }
 }
} 

 　　線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。

2）newFixedThreadPool
　　創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。示例代碼如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  for (int i = 0; i < 10; i++) {
   final int index = i;
   fixedThreadPool.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

　　因為線程池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒打印3個數字。
　　定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

3）newScheduledThreadPool
　　創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

　　表示延遲3秒執行。

　　定期執行示例代碼如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

　　表示延遲1秒後每3秒執行一次。

4）newSingleThreadExecutor
　　創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

　　結果依次輸出，相當於順序執行各個任務。

注意：以上的execute（）方法可以替換為submit（）方法，執行的結果是一樣的。

四、submit（）和execute（）的區別

　　JDK5往後，任務分兩類：一類是實現了Runnable接口的類，一類是實現了Callable接口的類。兩者都可以被ExecutorService執行，它們的區別是：

• execute(Runnable x) 沒有返回值。可以執行任務，但無法判斷任務是否成功完成。——實現Runnable接口
• submit(Runnable x) 返回一個future。可以用這個future來判斷任務是否成功完成。——實現Callable接口