Android线程池的使用

线程池，顾名思义就像是存放线程的池子一样的，我们需要使用线程时，就从这个池子里面去取线程使用，用完之后，线程又会放回这个池子里面，等待下次的线程调用。使用线程池有很多好处，首先线程池中的线程可以重复利用，可以减少线程创建和销毁的性能开销；其次，通过设置核心线程数和最大线程数，可以控制线程的并发数量，避免太多线程的并发开启争夺CPU资源；最后一点就是，线程池可以对线程进行有效的管理，比如ScheduledThreadPool可以延迟N秒执行任务，并且可以每隔M秒循环执行。
Android的线程池有四种类型，针对于不同的使用场景，后面我们会逐个讲到。这里我们要知道的是，具体实现线程池的创建管理的类是ThreadPoolExecutor,它实现了Executor接口。其实Android中的四种线程池，都是在ThreadPoolExecutor的基础上，通过不同的参数配置而形成的。我们来看看ThreadPoolExecutor的一个常用构造函数：

/**     * Creates a new {@code ThreadPoolExecutor} with the given initial     * parameters and default thread factory and rejected execution handler.     * It may be more convenient to use one of the {@link Executors} factory     * methods instead of this general purpose constructor.     *     * @param corePoolSize the number of threads to keep in the pool, even     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set     * @param maximumPoolSize the maximum number of threads to allow in the     *        pool     * @param keepAliveTime when the number of threads is greater than     *        the core, this is the maximum time that excess idle threads     *        will wait for new tasks before terminating.     * @param unit the time unit for the {@code keepAliveTime} argument     * @param workQueue the queue to use for holding tasks before they are     *        executed.  This queue will hold only the {@code Runnable}     *        tasks submitted by the {@code execute} method.     * @throws IllegalArgumentException if one of the following holds:<br>     *         {@code corePoolSize < 0}<br>     *         {@code keepAliveTime < 0}<br>     *         {@code maximumPoolSize <= 0}<br>     *         {@code maximumPoolSize < corePoolSize}     * @throws NullPointerException if {@code workQueue} is null     */    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             Executors.defaultThreadFactory(), defaultHandler);    }

这里说明一下这些参数：
corePoolSize：核心线程数，除非allowCoreThreadTimeOut被设置为true，否则核心线程一直不会被回收掉。
maximumPoolSize：最大线程数量，线程池中允许创建存活的最大线程数量，如果执行的任务大于这个数量，那么任务就需要排队了。
keepAliveTime：非核心线程在空闲的时候，允许存活的时间，如果非核心线程空闲的时间超过这个值，就会被回收掉。
unit：keepAliveTime这个数值的单位，枚举类型，有TimeUnit.MILLISECONDS（ms）、TimeUnit. SECONDS（s）等。
workQueue：缓存任务的队列，线程池的execute方法会把Runnable对象缓存起来。
Executors.defaultThreadFactory()：另一个构造方法里，这个参数其实是真正执行创建线程的工厂接口。
defaultHandler：这个是一个传递消息的接口。

下面我们分别来看看Android中的四种线程池：
1、FixThreadPool

public static ExecutorService newFixThreadPool(int nThreads){      return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());  }  //使用  Executors.newFixThreadPool(5).execute(r); 

从构造参数来看，FixThreadPool里面都是核心线程，如果当前线程数

public static ExecutorService newSingleThreadPool (int nThreads){      return new FinalizableDelegatedExecutorService ( new ThreadPoolExecutor (1, 1, 0, TimeUnit. MILLISECONDS, new LinkedBlockingQueue<Runnable>()) );  }  //使用  Executors.newSingleThreadPool ().execute(r); 

该线程里面只有一个存活的核心线程，所有的任务都需要排队执行，空闲的时候，该线程存活在线程池里面。

3、CachedThreadPool

public static ExecutorService newCachedThreadPool(){      return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit. SECONDS, new SynchronousQueue<Runnable>());  }  //使用  Executors.newCachedThreadPool().execute(r); 

CachedThreadPoold只会创建非核心线程，并且它所能创建的非核心线程是非常巨大的，因此也就意味着，所有的任务都能及时执行，线程不够就创建线程，空闲超过60S就会被回收。

4、SchedledThreadPool

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {        return new DelegatedScheduledExecutorService            (new ScheduledThreadPoolExecutor(1));    } public ScheduledThreadPoolExecutor(int corePoolSize) {        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,              new DelayedWorkQueue());    }//使用，延迟1秒执行，每隔2秒执行一次Runnable r  Executors. newScheduledThreadPool (5).scheduleAtFixedRate(r, 1000, 2000, TimeUnit.MILLISECONDS);  

ScheduledThreadPool具有定时执行和循环执行的功能。我们从构造参数中可以看到，它的核心线程只有一个，非核心线程数是接近无限大的，同时非核心线程数在空闲的时候就会被回收。