Java線程池（newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool 、newSingleThreadExector ）

1、new Thread的弊端

執行一個異步任務你還隻是如下new Thread嗎？

new Thread(new Runnable() {
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        }
    }
).start();

那你就out太多了，new Thread的弊端如下：

a. 每次new Thread建立對象性能差。

b. 線程缺乏統一管理，可能無限制建立線程，互相之間競争，及可能占用過多系統資源導緻當機或oom。

c. 缺乏更多功能，如定時執行、定期執行、線程中斷。

相比new Thread，Java提供的四種線程池的好處在于：

a. 重用存在的線程，減少對象建立、消亡的開銷，性能佳。

b. 可有效控制最大并發線程數，提高系統資源的使用率，同時避免過多資源競争，避免堵塞。

c. 提供定時執行、定期執行、單線程、并發數控制等功能。

2、Java 線程池

Executor介紹： http://blog.csdn.net/u011630575/article/details/51050091

Java通過Executors提供四種線程池，分别為：

newCachedThreadPool建立一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則建立線程。
newFixedThreadPool建立一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。
newScheduledThreadPool建立一個定長線程池，支援定時及周期性任務執行。
newSingleThreadExecutor 建立一個單線程化的線程池，它隻會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

(1)newCachedThreadPool：

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

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() {
            @Override
            public void run() {
               System.out.println(index);
            }
        });
    }

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

(2)newFixedThreadPool：

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

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
 
    fixedThreadPool.execute(new Runnable() {
 
        @Override
        public void run() {
           try {
               System.out.println(index);
               Thread.sleep(2000);
            } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
             }
         }
     });
}

因為線程池大小為3，每個任務輸出index後sleep 2秒，是以每兩秒列印3個數字。

定長線程池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()。可參考PreloadDataCache。

(3)newScheduledThreadPool：

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

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
 
   @Override
   public void run() {
      System.out.println("delay 3 seconds");
   }
}, 3, TimeUnit.SECONDS);

表示延遲3秒執行。

scheduleAtFixedRate 定期執行示例代碼如下：

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
   @Override
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

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

ScheduledExecutorService比Timer更安全，功能更強大

(4)newSingleThreadExecutor：

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

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
 
      @Override
      public void run() {
         try {
             System.out.println(index);
             Thread.sleep(2000);
          } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
          }
       }
   });
}

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

現行大多數GUI程式都是單線程的。Android中單線程可用于資料庫操作，檔案操作，應用批量安裝，應用批量删除等不适合并發但可能IO阻塞性及影響UI線程響應的操作。

線程池的作用：

線程池作用就是限制系統中執行線程的數量。

根據系統的環境情況，可以自動或手動設定線程數量，達到運作的最佳效果；

少了浪費了系統資源，多造成系統擁擠效率不高。

用線程池控制線程數量，其他線程排隊等候。

一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待程序，線程池的這一資源處于等待。當一個新任務需要運作時，如果線程池中有等待的工作線程，就可以開始運作了；否則進入等待隊列。

為什麼要用線程池:

1.減少了建立和銷毀線程的次數，每個工作線程都可以被重複利用，可執行多個任務。

2.可以根據系統的承受能力，調整線程池中工作線線程的數目，防止因為消耗過多的記憶體，而把伺服器累趴下(每個線程需要大約1MB記憶體，線程開的越多，消耗的記憶體也就越大，最後當機)。

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

真正的線程池接口是ExecutorService。

比較重要的幾個類：

ExecutorService：真正的線程池接口。

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

ThreadPoolExecutor： ExecutorService的預設實作。

ScheduledThreadPoolExecutor：繼承ThreadPoolExecutor的ScheduledExecutorService接口實作，周期性任務排程的類實作。

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

1.newSingleThreadExecutor

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

2.newFixedThreadPool

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

3.newCachedThreadPool

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

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

4.newScheduledThreadPool

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

執行個體代碼

一、固定大小的線程池，newFixedThreadPool：

package app.executors;  
 
import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  
 
/** 
 * Java線程：線程池 
 *  
 * @author xiho
 */  
public class Test {  
    public static void main(String[] args) {  
        // 建立一個可重用固定線程數的線程池  
        ExecutorService pool = Executors.newFixedThreadPool(2);  
        // 建立線程  
        Thread t1 = new MyThread();  
        Thread t2 = new MyThread();  
        Thread t3 = new MyThread();  
        Thread t4 = new MyThread();  
        Thread t5 = new MyThread();  
        // 将線程放入池中進行執行  
        pool.execute(t1);  
        pool.execute(t2);  
        pool.execute(t3);  
        pool.execute(t4);  
        pool.execute(t5);  
        // 關閉線程池  
        pool.shutdown();  
    }  
}  
 
class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println(Thread.currentThread().getName() + "正在執行。。。");  
    }  
}

輸出結果：

pool-1-thread-1正在執行。。。  
pool-1-thread-3正在執行。。。  
pool-1-thread-4正在執行。。。  
pool-1-thread-2正在執行。。。  
pool-1-thread-5正在執行。。。

改變ExecutorService pool = Executors.newFixedThreadPool(5)中的參數：ExecutorService pool = Executors.newFixedThreadPool(2)，輸出結果是：

pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-2正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-2正在執行。。。

從以上結果可以看出，newFixedThreadPool的參數指定了可以運作的線程的最大數目，超過這個數目的線程加進去以後，不會運作。其次，加入線程池的線程屬于托管狀态，線程的運作不受加入順序的影響。

二、單任務線程池，newSingleThreadExecutor：

僅僅是把上述代碼中的ExecutorService pool = Executors.newFixedThreadPool(2)改為ExecutorService pool = Executors.newSingleThreadExecutor();

輸出結果：

pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。

可以看出，每次調用execute方法，其實最後都是調用了thread-1的run方法。

三、可變尺寸的線程池，newCachedThreadPool：

與上面的類似，隻是改動下pool的建立方式：ExecutorService pool = Executors.newCachedThreadPool();

輸出結果：

pool-1-thread-1正在執行。。。  
pool-1-thread-2正在執行。。。  
pool-1-thread-4正在執行。。。  
pool-1-thread-3正在執行。。。  
pool-1-thread-5正在執行。。。

這種方式的特點是：可根據需要建立新線程的線程池，但是在以前構造的線程可用時将重用它們。

四、延遲連接配接池，newScheduledThreadPool：

public class TestScheduledThreadPoolExecutor {
 
    public static void main(String[] args) {
 
        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
 
        exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間就觸發異常
 
              @Override
 
               publicvoid run() {
 
                   //throw new RuntimeException();
 
                  System.out.println("================");
 
                }
 
        }, 1000, 5000, TimeUnit.MILLISECONDS);
 
        exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間列印系統時間，證明兩者是互不影響的
 
             @Override
 
             publicvoid run() {
 
                    System.out.println(System.nanoTime());
             }
 
        }, 1000, 2000, TimeUnit.MILLISECONDS);
 
  }
}
輸出結果：

================
8384644549516

8386643829034

8388643830710

================

8390643851383

8392643879319

8400643939383

Java線程池（newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool 、newSingleThreadExector ）

1、new Thread的弊端

2、Java 線程池

(1)newCachedThreadPool：

(2)newFixedThreadPool：

(3)newScheduledThreadPool：

(4)newSingleThreadExecutor：

線程池的作用：

為什麼要用線程池:

1.newSingleThreadExecutor

2.newFixedThreadPool

3.newCachedThreadPool

4.newScheduledThreadPool

執行個體代碼

一、固定大小的線程池，newFixedThreadPool：

二、單任務線程池，newSingleThreadExecutor：

三、可變尺寸的線程池，newCachedThreadPool：

四、延遲連接配接池，newScheduledThreadPool：

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method