android线程池ThreadPoolExecutor的理解

线程池

我自己理解看来。线程池顾名思义就是一个容器的意思，容纳的就是ThreadorRunable,
注意：每一个线程都是需要CPU分配资源去执行的。

如果由于总是new Thread()开启一个线程，那么就会大量的消耗CPU的资源，导致Android运行变慢，甚至OOM(out of memory) ,

因而java就出现了一个ThreadPoolExecutor来管理这些线程。控制最多的线程数maximumPoolSize，
核心线程数corePoolSize，来管理我们需要开启的线程数。

目的：减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务

所以：我们就可以根据手机的CPU核数来控制App可以开的最大线程数。保证程序的合理运行

创建线程池对象

线程池几个参数的理解:

1. 比如去火车站买票, 有10个售票窗口, 但只有5个窗口对外开放. 那么对外开放的5个窗口称为核心线程数corePoolSize,

2. 而最大线程数maximumPoolSize是10个窗口.

3. 如果5个窗口都被占用, 那么后来的人就必须在后面排队, 但后来售票厅人越来越多, 已经人满为患, 就类似于线程队列new LinkedBlockingQueue<Runnable>()已满.

4. 这时候火车站站长下令, 把剩下的5个窗口也打开, 也就是目前已经有10个窗口同时运行. 后来又来了一批人,
5. 10个窗口也处理不过来了, 而且售票厅人已经满了, 这时候站长就下令*入口,不允许其他人再进来, 这就是线程异常处理策略.
6. 而线程存活时间keepAliveTime指的是, 允许售票员休息的最长时间, 以此限制售票员偷懒的行时间。休息一下在处理。

单列的模式创建线程池ThreadPoolExecutor

    public static class ThreadPool
    {
        public static ThreadPoolExecutor executor = null;

        private int corePoolSize;
        private int maximumPoolSize;
        private long keepAliveTime = 0; // 限制线程的的最大存活时间

        public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime)
        {
            super();
            this.corePoolSize = corePoolSize;  //核心线程数
            this.maximumPoolSize = maximumPoolSize; //最大线程 ，当核心线程用完时。决定是否开启最大线程
            this.keepAliveTime = keepAliveTime;  //线程排队时间，
        }

        /**
         * 线程池：就是把一堆线程放在一起来管理。 1.通过一定的管理机制。来处理线程额执行顺序 2.管理最多可以同时执行的线程数。
         * 3.其他线程通过队列的形式，也就是排队的形式来管理线程的并发数。
         * 
         * @param runnable
         */
        public void execute(Runnable runnable)
        {
            if (runnable == null)
            {
                return;
            }

            if (executor == null)
            {

                executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime,
                        TimeUnit.MILLISECONDS,// 时间单位
                        new LinkedBlockingQueue<Runnable>(),// 线程队列
                        Executors.defaultThreadFactory(),//线程工厂
                        new AbortPolicy());
            }
            // 给线程池里面添加一个线程
            executor.execute(runnable);
        }

创建线程池管理者 ThreadManager

通过给线程加锁机制。来保证线程安全，以及当前程序当中只有一个x线程池ThreadPool

/**
 * 线程管理者。
 * 
 * @author H_lang
 * 
 */
public class ThreadManager
{

    private static ThreadPool threadPool; // 单列的线程池对象。

    /**
     * 单列，线程安全
     * 获取一个线程池对象
     * @return
     */
    public static ThreadPool getThreadPool()
    {
        if (threadPool == null)
        {
            //枷锁
            synchronized (ThreadManager.class)
            {
                if (threadPool == null)
                {
                //核心线程数，等于处理器个数乘2
                    int corePoolSize = Runtime.getRuntime().availableProcessors()*2;
                    int maximumPoolSize = 10;
                    long keepAliveTime = 0L;
                    threadPool = new ThreadPool(corePoolSize, maximumPoolSize, keepAliveTime);
                }
            }
        }

        return threadPool;
    }

    public static class ThreadPool
    {
        public static ThreadPoolExecutor executor = null;

        private int corePoolSize;
        private int maximumPoolSize;
        private long keepAliveTime = 0; // 限制线程的的最大存活时间

        public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime)
        {
            super();
            this.corePoolSize = corePoolSize;  //核心线程数
            this.maximumPoolSize = maximumPoolSize; //最大线程 ，当核心线程用完时。决定是否开启最大线程
            this.keepAliveTime = keepAliveTime;  //线程排队时间，
        }

        /**
         * 线程池：就是把一堆线程放在一起来管理。 1.通过一定的管理机制。来处理线程额执行顺序 2.管理最多可以同时执行的线程数。
         * 3.其他线程通过队列的形式，也就是排队的形式来管理线程的并发数。
         * 
         * @param runnable
         */
        public void execute(Runnable runnable)
        {
            if (runnable == null)
            {
                return;
            }

            if (executor == null)
            {

                executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime,
                        TimeUnit.MILLISECONDS,// 时间单位
                        new LinkedBlockingQueue<Runnable>(),// 线程队列
                        Executors.defaultThreadFactory(),//线程工厂
                        new AbortPolicy());
            }
            // 给线程池里面添加一个线程
            executor.execute(runnable);
        }

    }
}