Android中线程池的使用

在我们日常使用中，通常我们要执行一个异步任务的时候，会通过随手 new Thread() 的
方式创建线程。使用这种方式有很多弊端：比如无法统一管理，定时执行、定期执行、线
程中断等。这样的做法会提高系统的开销。如果需要设计性能比较好的APP,则一定要使用
线程池。
Android 里面提供了一些封装好的线程池给我们，大家可能不太理解线程池是什么原理，
下面是一个简单的demo，希望可以对理解线程池有帮助：

        public class ThreadPool {
            int maxCount = 3;
            AtomicInteger count =new AtomicInteger(0);// 当前开的线程数  count=0
            LinkedList<Runnable> runnables = new LinkedList<Runnable>();

            public void execute(Runnable runnable) {
                runnables.add(runnable);
                if(count.incrementAndGet()<=3){
                    createThread();
                }
            }
            private void createThread() {
                new Thread() {
                    @Override
                    public void run() {
                        super.run();
                        while (true) {
                            // 取出来一个异步任务
                            if (runnables.size() > 0) {
                                Runnable remove = runnables.remove(0);
                                if (remove != null) {
                                    remove.run();
                                }
                            }else{
                                //  等待状态   wake();
                            }
                        }
                    }
                }.start();
            }
        }

上面只是一个非常简陋的demo，只能说明一下线程池是什么原理。下面我介绍一个Java中的线程池对象：ThreadPoolExecutor，在Android中我们通常会定义一个单例的类来管理线程池：

    /**
             * 执行任务
             * @param runnable
             */
            public void execute(Runnable runnable) {
                if (pool == null) {
                    // 创建线程池
                    /*
                     * 参数一. 线程池里面管理多少个线程
                     * 参数二. 如果排队满了, 额外的开的线程数
                     * 参数三. 如果线程池没有要执行的任务 存活多久
                     * 参数四. 时间的单位 
                     * 参数五. 如果 线程池里管理的线程都已经用了,剩下的任务 
                     * 临时存到LinkedBlockingQueue对象中 排队
                     */
                    pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
                            time, TimeUnit.MILLISECONDS,
                            new LinkedBlockingQueue<Runnable>(10));
                }
                pool.execute(runnable); // 调用线程池 执行异步任务
            }
            /**
             * 取消任务
             * @param runnable
             */
            public void cancel(Runnable runnable) {
                if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
                    pool.remove(runnable); // 取消异步任务
                }
            }

每当我执行一个线程的时候就调用execute(Runnable runnable)方法，所有的线程都会添加到
线程池中使用，我们也可以随时取消任务，当线程任务执行完毕，如果有空闲线程，系统就会
用空闲线程执行新的任务，而不是每次都新建一个线程，这样处理之后，性能可以得到很大的
提高。
具体ThreadPoolExecutor的使用可以参考：http://blog.csdn.net/cutesource/article/details/6061229
这里面详细解释了ThreadPoolExecutor 运行机制。