Android 线程池

Java为我们提供了ExecutorService线程池来优化和管理线程的使用
使用线程池管理线程的优点

1、线程的创建和销毁由线程池维护，一个线程在完成任务后并不会立即销毁，而是由后续的任务复用这个线程，从而减少线程的创建和销毁，节约系统的开销

2、线程池旨在线程的复用，这就可以节约我们用以往的方式创建线程和销毁所消耗的时间，减少线程频繁调度的开销，从而节约系统资源，提高系统吞吐量

3、在执行大量异步任务时提高了性能

4、Java内置的一套ExecutorService线程池相关的api，可以更方便的控制线程的最大并发数、线程的定时任务、单线程的顺序执行等

使用ThreadPoolExecutor创建一个线程池管理类：

package com.pdoctor4u.activity;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by chenxiangyu on 16/2/19.
 */
public class ThreadManager {
    private static ThreadProxyPool threadProxyPool;
    private static Object obj = new Object();


    public static ThreadProxyPool getThreadProxyPool() {
        synchronized (obj) {
            if (threadProxyPool == null) {
                threadProxyPool = new ThreadProxyPool(5,5,5L);
            }
            return threadProxyPool;
        }
    }


    public static class ThreadProxyPool {
        private ThreadPoolExecutor threadPoolExecutor;
        private int corePoolSize;
        private int maximumPoolSize;
        private long keepAliveTime;

        private ThreadProxyPool() {

        }

        private ThreadProxyPool(int corePoolSize, int maximumPoolSize,long keepAliveTime) {
            this.corePoolSize = corePoolSize;
            this.keepAliveTime = keepAliveTime;
            this.maximumPoolSize = maximumPoolSize;
        }

        public void excute(Runnable runnable) {
            if (runnable == null) {
                return;
            }
            if (threadPoolExecutor == null || threadPoolExecutor.isShutdown()) {
                threadPoolExecutor = new ThreadPoolExecutor(
                        //3  核心线程数
                        corePoolSize,
                        //5 最大线程数
                        maximumPoolSize,
                        //没有执行任务的线程存活时间
                        keepAliveTime,
                        //存活时间的单位
                        TimeUnit.MICROSECONDS,
                        //线程中要准备去执行任务排队的队列
                        new LinkedBlockingDeque<Runnable>(),
                        //线程的工厂,创建线程
                        Executors.defaultThreadFactory(),
                        //队列中如果放置不下任务时候的异常处理
                        new ThreadPoolExecutor.AbortPolicy());
            }
            threadPoolExecutor.execute(runnable);
        }

        //需要中止的是线程池中任务队列里面的任务
        public void cancel(Runnable runnable) {
            if (runnable != null) {
                //获取线程池对象,然后从其内部去移除相应的任务
                threadPoolExecutor.getQueue().remove(runnable);
            }
        }

    }
}

官方也不推荐使用这种方法来创建线程池，而是推荐使用Executors的工厂方法来创建线程池，Executors类是官方提供的一个工厂类，它里面封装好了众多功能不一样的线程池，从而使得我们创建线程池非常的简便，主要提供了如下四种功能不一样的线程池：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。