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");
        }
    }
}