1、線程池作用

線程池作用就是限制系統中執行線程的數量，且復用以前工作線程。根據當前的環境，手動配置線程池，減少對系統資源的浪費和擁擠。用線程池控制線程數量，同時運行X個core線程，其他線程排隊等候。一個工作任務執行完畢之后，從隊列前面取一個再執行。若隊列中沒有等待線程，線程池資源處于等待狀態。

2、使用線程池的好處

線程池可根據系統的承受能力，調整線程池中工作線程的數目，防止OOM或者應用卡死。（控制線程數量，防止消耗完所有的內存）如果不使用線程池，線程將會無法統一管理，而且每次都在new 新的對象，不會復用以前new的工作線程。（減少創建銷毀線程所花的時間以及系統資源的開銷）

3、Java自帶的4種線程池

SingleThreadExecutor

單線程化的Executor，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。最大特點是可以保證按照順序執行各個任務，不會有多個線程是可活動的。

ScheduledThreadPool

定長線程池，可控制線程最大并發數，支持定時及周期性任務執行，類似于Timer。

FixedThreadPool

定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。

CachedThreadPool

可緩存的線程池。可創建的最大線程數量沒有限制，如果長時間(60秒)沒有向線程池中提交新任務，該線程會被終止。

AsyncTask

AsyncTask也是使用線程池來控制的，是用ThreadPollExecutor，core線程數量是5，線程池最大值是128，也就是說最多5個線程同時在執行，最多128個任務在隊列中排隊等待。

Timer和ScheduledExecutorService的比較

Timer在執行定時任務時只會創建一個線程，如果存在多個任務，任務耗時時間過長，會發生兩個任務執行間隔不準確的情況。ScheduledExecutorService內部是線程池，不會因為任務耗時過長而讓其時間的間隔不正確。兩個任務線程互相不會干擾。Timer在執行定時任務時候依賴與系統的時間，比如系統時間人為的去改變了，執行結果也會發生改變。ScheduledExecutorService是基于時間的延時，不會依賴與系統時間改變的。綜上所述使用ScheduledExecutorService代替Timer比較好。

下面是分享個自己封裝的一個線程池管理工具

/**
 * @Description: java 線程池使用工具
 * @suthor GuoXC
 * @date 2016/12/06 11:29
 */
public class ThreadManager {
    private ExecutorService cachedThreadService;//可緩存線程池
    private ExecutorService fixedThreadService;//定長線程池
    private ScheduledExecutorService scheduledThreadService;//定長線程池
    private ExecutorService singleThreadExecutor;//單線程線程池
    private static ThreadManager manager;

    private ThreadManager() {
    }

    /**
     * 單例
     *
     * @return ThreadManager
     */
    public synchronized static ThreadManager getInstance() {
        if (manager == null) { // 解決效率問題
            synchronized (ThreadManager.class) {
                if (manager == null) {
                    manager = new ThreadManager();
                }
            }
        }
        return manager;
    }

    /**
     * 1,可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
     *
     * @param runnable 線程任務
     */
    public void cachedThread(Runnable runnable) {
        if (runnable == null) return;
        if (cachedThreadService == null) {
            cachedThreadService = Executors.newCachedThreadPool();
        }
        if (!cachedThreadService.isShutdown() || !cachedThreadService.isTerminated()) {
            cachedThreadService.execute(runnable);
        } else {
            throw new RuntimeException("CachedThreadService is shut down or terminated");
        }
    }

    /**
     * 2,定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。
     *
     * @param runnable 線程任務
     */
    public void fixedThread(Runnable runnable) {
        if (runnable == null) return;
        if (fixedThreadService == null) {
            fixedThreadService = Executors.newFixedThreadPool(3);
        }
        if (!fixedThreadService.isTerminated() || !fixedThreadService.isTerminated()) {
            fixedThreadService.execute(runnable);
        } else {
            throw new RuntimeException("FixedThreadService is shut down or terminated");
        }
    }

    /**
     * 3.1,定長線程池，延遲執行
     *
     * @param runnable 線程任務
     * @param delay    延遲 單位 S
     */
    public void scheduledThread(Runnable runnable, long delay) {
        if (runnable == null) return;
        if (scheduledThreadService == null) {
            scheduledThreadService = Executors.newScheduledThreadPool(5);
        }
        if (!scheduledThreadService.isTerminated() || !scheduledThreadService.isShutdown()) {
            scheduledThreadService.schedule(runnable, delay, TimeUnit.SECONDS);
        } else {
            throw new RuntimeException("ScheduledThreadService is shut down or terminated");
        }
    }

    /**
     * 3.2,定長線程池，定期執行,可以用來做定時器
     *
     * @param runnable 線程任務
     * @param delay    延遲 單位 S
     * @param space    執行間隔 單位 S
     */
    public void scheduledThread(Runnable runnable, long delay, long space) {
        if (runnable == null) return;
        if (scheduledThreadService == null) {
            scheduledThreadService = Executors.newScheduledThreadPool(2);
        }
        if (!scheduledThreadService.isShutdown() || !scheduledThreadService.isTerminated()) {
            scheduledThreadService.scheduleAtFixedRate(runnable, delay, space, TimeUnit.SECONDS);
        } else {
            throw new RuntimeException("ScheduledThreadService is shut down or terminated");
        }
    }

    /**
     * 4,單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。
     *
     * @param runnable 線程任務
     */
    public void singleThread(Runnable runnable) {
        if (runnable == null) return;
        if (singleThreadExecutor == null) {
            singleThreadExecutor = Executors.newSingleThreadExecutor();
        }
        if (!singleThreadExecutor.isShutdown() || !singleThreadExecutor.isTerminated()) {
            singleThreadExecutor.execute(runnable);
        } else {
            throw new RuntimeException("SingleThreadExecutor is shut down or terminated");
        }
    }
}