款android使用线程池,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:

* {@code corePoolSize < 0}

* {@code keepAliveTime < 0}

* {@code maximumPoolSize <= 0}

* {@code maximumPoolSize < corePoolSize}

* @throws NullPointerException if {@code workQueue} is null

*/

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue 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());

}

//使用

Executors.newFixThreadPool(5).execute(r);

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

public static ExecutorService newSingleThreadPool (int nThreads){

return new FinalizableDelegatedExecutorService ( new ThreadPoolExecutor (1, 1, 0, TimeUnit. MILLISECONDS, new LinkedBlockingQueue()) );

}

//使用

Executors.newSingleThreadPool ().execute(r);

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

3、CachedThreadPool

public static ExecutorService newCachedThreadPool(){

return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit. SECONDS, new SynchronousQueue());

}

//使用

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