java多線程ExecutorService

一、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. 提供定時執行、按期執行、單線程、併發數控制等功能。

 

二、Java 線程池
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秒執行。
 
按期執行示例代碼以下：

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線程響應的操做。

 

Executor vs ExecutorService vs Executors三者的區別：

正如上面所說，這三者均是 Executor 框架中的一部分。Java 開發者頗有必要學習和理解他們，以便更高效的使用 Java 提供的不一樣類型的線程池。總結一下這三者間的區別，以便你們更好的理解：

• Executor 和 ExecutorService 這兩個接口主要的區別是：ExecutorService 接口繼承了 Executor 接口，是 Executor 的子接口
• Executor 和 ExecutorService 第二個區別是：Executor 接口定義了 execute()方法用來接收一個Runnable接口的對象，而 ExecutorService 接口中的 submit()方法能夠接受Runnable和Callable接口的對象。
• Executor 和 ExecutorService 接口第三個區別是 Executor 中的 execute() 方法不返回任何結果，而 ExecutorService 中的 submit()方法能夠經過一個 Future 對象返回運算結果。
• Executor 和 ExecutorService 接口第四個區別是除了容許客戶端提交一個任務，ExecutorService 還提供用來控制線程池的方法。好比：調用 shutDown() 方法終止線程池。能夠經過 《Java Concurrency in Practice》 一書瞭解更多關於關閉線程池和如何處理 pending 的任務的知識。
• Executors 類提供工廠方法用來建立不一樣類型的線程池。好比: newSingleThreadExecutor() 建立一個只有一個線程的線程池，newFixedThreadPool(int numOfThreads)來建立固定線程數的線程池，newCachedThreadPool()能夠根據須要建立新的線程，但若是已有線程是空閒的會重用已有線程。

總結

下表列出了 Executor 和 ExecutorService 的區別：

Executor	ExecutorService
Executor 是 Java 線程池的核心接口，用來併發執行提交的任務	ExecutorService 是 Executor 接口的擴展，提供了異步執行和關閉線程池的方法
提供execute()方法用來提交任務	提供submit()方法用來提交任務
execute()方法無返回值	submit()方法返回Future對象，可用來獲取任務執行結果
不能取消任務	能夠經過Future.cancel()取消pending中的任務
沒有提供和關閉線程池有關的方法	提供了關閉線程池的方法

測試異步例子

public class NestedTest {
    final static ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
　　

　　public static void main(String[] args) {
　　

　　for (int i = 1; i <= 5; i++) {
        System.out.println(i + " ");
    }

    //放進10個線程並行跑
    for (int i = 0; i < 10; i++) {
         cachedThreadPool.execute(new Runnable() {
         @Override
         public void run() {
                 try {
                     Thread.sleep(3000);
                     System.out.println("執行1");
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
         }
       });
    }

    cachedThreadPool.execute(new Runnable() {
        @Override
        public void run() {
            while(true) {
                try {
                    Thread.sleep(1000);
                    System.out.println("執行2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });

    cachedThreadPool.shutdown();//關閉執行器
    System.out.println("完成了嗎");

　　}

}