java 浅析对象池ThreadPool

回忆一下java的线程池的知识。

一个app中可能因为需要会开很多个线程去执行任务，也许为图省事直接new 一个thread，其实它同时会带来很大的弊端，如内存过度消耗，创建和消耗对象费时费CPU资源等

线程池可以看做装载线程的容器，当打开一个app时，在application中可以声明并创建一个线程池来管理整个app的线程，因为一个应用程序最多只能有一个线程池。

那么为什么要创建线程池呢？

1.提升性能。创建和消耗对象费时费CPU资源，引入线程池可以减少了创建和销毁线程所需的时间，从而提高效率
2.防止内存过度消耗。控制活动线程的数量，防止并发线程过多。

所有线程都应该装入线程池么？答案是：并不是

那么什么样的线程应该单独的new thread来完成呢？

1.任务需要很长时间

2.线程需要被指定优先级

3.需要对线程进行操作（wait）

所以ThreadPool应该适合于一些任务所需时间短，相互不影响的线程。

java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。(我习惯用这种)
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

这里提供一个线程池的工具类，可以去操作学习。

public class ThreadPoolManger {


    public enum Type {
        SingleThread,
        FixedThread,
        CachedThread,
        ScheduledSingleThread
    }


    private static final int DEFAULT_THREADS = 3;


    private ExecutorService executorService = null;


    private Type nowType;


    public ThreadPoolManger(Type type) {
        nowType = type;
        switch (type) {
            case SingleThread:
                executorService = Executors.newSingleThreadExecutor();
                break;
            case FixedThread:
                executorService = Executors.newFixedThreadPool(DEFAULT_THREADS);
                break;
            case CachedThread:
                executorService = Executors.newCachedThreadPool();
                break;
            case ScheduledSingleThread:
                executorService = Executors.newSingleThreadScheduledExecutor();
                break;
        }
    }


    /**
     * 延迟一定时间后开始执行Runnable,效果同{@link new Handler().postDelay}
     *
     * @param runnable     执行的任务
     * @param initialDelay 延迟时间
     */
    public void schedule(Runnable runnable, long initialDelay) {
        ((ScheduledExecutorService) executorService).schedule(runnable, initialDelay, TimeUnit.MILLISECONDS);
    }


    /**
     * 延迟一定时间后，开始执行Runnable，完成后延迟一定时间再重新执行Runnable
     *
     * @param runnable     执行的任务
     * @param initialDelay 初始延迟时间
     * @param delay        上次完成后至下次开始延迟的时间
     */
    public void scheduleWithFixedDelay(Runnable runnable, long initialDelay, long delay) {
        ((ScheduledExecutorService) executorService).scheduleWithFixedDelay(runnable, initialDelay, delay, TimeUnit.MILLISECONDS);
    }


    /**
     * 每隔固定时间开始执行Runnable，固定频率
     *
     * @param runnable     执行的任务
     * @param initialDelay 初始延迟时间
     * @param period       每隔period时间再次执行Runnable任务
     */
    public void scheduleWithFixedRate(Runnable runnable, long initialDelay, long period) {
        ((ScheduledExecutorService) executorService).scheduleAtFixedRate(runnable, initialDelay, period, TimeUnit.MILLISECONDS);
    }


    public void execute(Runnable runnable) {
        executorService.execute(runnable);
    }


    public void execute(List<Runnable> runnables) {
        for (Runnable runnable : runnables) {
            executorService.execute(runnable);
        }
    }


    public Future<?> submit(Runnable runnable) {
        return executorService.submit(runnable);
    }


    public boolean isShutDown() {
        return executorService.isShutdown();
    }


    public void shutDown() {
        executorService.shutdown();
    }


    public void shutDownNow() {
        executorService.shutdownNow();
        executorService = null;
    }


}

那么