Android、Java线程池的使用

ThreadPoolExecutor的原理

经典书《Java Concurrency in Pratice(Java并发编程实战)》第8章，浓缩如下：

1. 每次提交任务时，如果线程数还没达到coreSize就创建新线程并绑定该任务。

所以第coreSize次提交任务后线程总数必达到coreSize，不会重用之前的空闲线程。

2. 线程数达到coreSize后，新增的任务就放到工作队列里，而线程池里的线程则努力的使用take()从工作队列里拉活来干。

3. 如果队列是个有界队列，又如果线程池里的线程不能及时将任务取走，工作队列可能会满掉，插入任务就会失败，此时线程池就会紧急的再创建新的临时线程来补救。

4. 临时线程使用poll(keepAliveTime，timeUnit)来从工作队列拉活，如果时候到了仍然两手空空没拉到活，表明它太闲了，就会被解雇掉。

5. 如果core线程数＋临时线程数 >maxSize，则不能再创建新的临时线程了，转头执行RejectExecutionHanlder。默认的AbortPolicy抛 RejectedExecutionException异常，其他选择包括静默放弃当前任务(Discard)，放弃工作队列里最老的任务 (DisacardOldest)，或由主线程来直接执行(CallerRuns)，或你自己发挥想象力写的一个。

new Thread的弊端 

执行一个异步任务你还只是如下new Thread吗？

new Thread(new Runnable() { 	@Override	public void run() {		// TODO Auto-generated method stub	} }).start();

new Thread的弊端如下：

a. 每次new Thread新建对象性能差。

b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。

c. 缺乏更多功能，如定时执行、定期执行、线程中断。

相比new Thread，Java提供的四种线程池的好处在于：

a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。

b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。

c. 提供定时执行、定期执行、单线程、并发数控制等功能。

四种线程池

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

在JDK帮助文档中，有如此一段话：

“强烈建议程序员使用较为方便的 Executors 工厂方法 Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）Executors.newFixedThreadPool(int)（固定大小线程池）和Executors.newSingleThreadExecutor()（单个后台线程），它们均为大多数使用场景预定义了设置。

newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

JavaAPI源码：

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue<Runnable>());

}

示例代码如下：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) {	final int index = i;	try {		Thread.sleep(index * 1000);	} catch (InterruptedException e) {		e.printStackTrace();	} 	cachedThreadPool.execute(new Runnable() { 		@Override		public void run() {			System.out.println(index);		}	}); }

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

JavaAPI源码：

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());

}

示例代码如下：

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); for (int i = 0; i < 10; i++) {	final int index = i;	fixedThreadPool.execute(new Runnable() { 		@Override		public void run() {			try {				System.out.println(index);				Thread.sleep(2000);			} catch (InterruptedException e) {				// TODO Auto-generated catch block				e.printStackTrace();			}		}	}); }

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。

newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); scheduledThreadPool.schedule(new Runnable() { 	@Override	public void run() {		System.out.println("delay 3 seconds");	} }, 3, TimeUnit.SECONDS);

表示延迟3秒执行。

定期执行示例代码如下：

scheduledThreadPool.scheduleAtFixedRate(new Runnable() { 	@Override	public void run() {		System.out.println("delay 1 seconds, and excute every 3 seconds");	} }, 1, 3, TimeUnit.SECONDS);

表示延迟1秒后每3秒执行一次。

ScheduledExecutorService比Timer更安全，功能更强大。

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

Java源码：

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>()));

}

示例代码如下：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) {	final int index = i;	singleThreadExecutor.execute(new Runnable() { 		@Override		public void run() {			try {				System.out.println(index);				Thread.sleep(2000);			} catch (InterruptedException e) {				// TODO Auto-generated catch block				e.printStackTrace();			}		}	}); }

结果依次输出，相当于顺序执行各个任务。

现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

深度剖析

线程池介绍

线程池：首先创建一些线程，当服务器接收到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，服务完后并不关闭该线程，而是将该线程还回到线程池中。

在线程池的编程模式下，任务是提交给整个线程池的，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，找到后再把任务交给内部某个空闲的线程，这就是封装。记住：任务是提交给整个线程池的，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。

假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

一个线程池包括以下四个基本组成部分：

1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；

2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；

3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；

4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：

假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

hreadPoolExecutor的完整构造方法的是：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

部分参数解析

BlockingQueue

在JDK中，其实已经说得很清楚了，一共有三种类型的queue。以下为引用：（我会稍微修改一下，并用红色突出显示）

所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：

• 如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。（什么意思？如果当前运行的线程小于corePoolSize，则任务根本不会存放，添加到queue中，而是直接抄家伙（thread）开始运行）
• 如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。
• 如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。 首先需要知道queue上的三种类型。 排队有三种通用策略：

1. 直接提交。工作队列的默认选项是SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
2. 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
3. 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueu）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

RejectedExecutionHandler

当我们创建线程池并且提交任务失败时，线程池会回调RejectedExecutionHandler接口的rejectedExecution(Runnable task, ThreadPoolExecutor executor)方法来处理线程池处理失败的任务，其中task 是用户提交的任务，而executor是当前执行的任务的线程池。

同时JDK也为我们实现了四种RejectedExecutionHandler 实现类。

• ThreadPoolExecutor.AbortPolicy()抛出java.util.concurrent.RejectedExecutionException异常 终止策略是默认的饱和策略；
• ThreadPoolExecutor.CallerRunsPolicy()当抛出RejectedExecutionException异常时，会调rejectedExecution方法 调用者运行策略实现了一种调节机制，该策略既不会抛弃任务也不会爆出异常，而是将任务退回给调用者，从而降低新任务的流量
• ThreadPoolExecutor.DiscardOldestPolicy()抛弃旧的任务；当新提交的任务无法保存到队列中等待执行时将抛弃最旧的任务，然后尝试提交新任务。如果等待队列是一个优先级队列，抛弃最旧的策略将导致抛弃优先级最高的任务，因此AbortPolicy最好不要和优先 级队列一起使用。
• ThreadPoolExecutor.DiscardPolicy()抛弃当前的任务

ThreadFactory

线程池最主要的一项工作，就是在满足某些条件的情况下创建线程。而在ThreadPoolExecutor线程池中，创建线程的工作交给ThreadFactory来完成。要使用线程池，就必须要指定ThreadFactory。

类似于上文中，如果我们使用的构造函数时并没有指定使用的ThreadFactory，这个时候ThreadPoolExecutor会使用一个默认的ThreadFactory：DefaultThreadFactory。（这个类在Executors工具类中）

当然，在某些特殊业务场景下，您还可以使用一个自定义的ThreadFactory线程工厂，如下代码片段：

package test.thread.pool;

import java.util.concurrent.ThreadFactory;

/**

* 测试自定义的一个线程工厂

* @author yinwenjie

*/

public class TestThreadFactory implements ThreadFactory {

@Override

public Thread newThread(Runnable r) {

// do something before new thread created;

// create new thread ， and return

return new Thread(r);

}

}

SampleCode

1.RejectedExecutionHandler

public class MyRejectedExecutionHandler implements RejectedExecutionHandler {

@Override

public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {

// TODO Auto-generated method stub

System.out.println("Begin exception handler-----------");

// 执行失败任务

new Thread(task, "exception by pool").start();

// 打印线程池的对象

System.out.println("The pool RejectedExecutionHandler = "

+ executor.toString());

}

}

2.ThreadPoolConfig

public class ThreadPoolConfig {

// 池中所保存的线程数，包括空闲线程。

private int corePoolSize;

// 池中允许的最大线程数。

private int maximumPoolSize;

// 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

private long keepAliveTime;

// 参数的时间单位。

private TimeUnit unit;

// 执行前用于保持任务的队列。此队列仅由保持 execute 方法提交的 Runnable 任务。

private BlockingQueue<Runnable> workQueue;

// 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。

private RejectedExecutionHandler handler;

// 配置文件自身对象

private static ThreadPoolConfig config;

/**

* 单例模式

*/

private ThreadPoolConfig() {

}

/**

* 获取配置文件对象

*

* @return

*/

public static ThreadPoolConfig getInstance() {

if (config == null) {

config = new ThreadPoolConfig();

}

return config;

}

public int getCorePoolSize() {

return corePoolSize;

}

public void setCorePoolSize(int corePoolSize) {

this.corePoolSize = corePoolSize;

}

public int getMaximumPoolSize() {

return maximumPoolSize;

}

public void setMaximumPoolSize(int maximumPoolSize) {

this.maximumPoolSize = maximumPoolSize;

}

public long getKeepAliveTime() {

return keepAliveTime;

}

public void setKeepAliveTime(long keepAliveTime) {

this.keepAliveTime = keepAliveTime;

}

public TimeUnit getUnit() {

return unit;

}

public void setUnit(TimeUnit unit) {

this.unit = unit;

}

public BlockingQueue<Runnable> getWorkQueue() {

return workQueue;

}

public void setWorkQueue(BlockingQueue<Runnable> workQueue) {

this.workQueue = workQueue;

}

public RejectedExecutionHandler getHandler() {

return handler;

}

public void setHandler(RejectedExecutionHandler handler) {

this.handler = handler;

}

}

3.ThreadPoolFactory

public class ThreadPoolFactory {

// 线程池

private static ThreadPoolExecutor pool;

// 自身对象

private static ThreadPoolFactory factory;

/**

* 私有构造函数

*/

private ThreadPoolFactory() {

}

/**

* 获取工厂对象

*

* @param config

* @return

*/

public static ThreadPoolFactory getInstance(ThreadPoolConfig config) {

if (factory == null) {

factory = new ThreadPoolFactory();

}

if (pool == null) {

if (config.getHandler() == null) {

pool = new ThreadPoolExecutor(config.getCorePoolSize(),

config.getMaximumPoolSize(), config.getKeepAliveTime(),

config.getUnit(), config.getWorkQueue());

} else {

pool = new ThreadPoolExecutor(config.getCorePoolSize(),

config.getMaximumPoolSize(), config.getKeepAliveTime(),

config.getUnit(), config.getWorkQueue(),

config.getHandler());

}

}

System.out.println("pool create= " + pool.toString());

return factory;

}

/**

* 添加线程池任务

*

* @param run

*/

public synchronized void addTask(Runnable run) {

pool.execute(run);

}

/**

* 添加线程池任务

*

* @param runs

*/

public synchronized void addTask(List<Runnable> runs) {

if (runs != null) {

for (Runnable r : runs) {

this.addTask(r);

}

}

}

public int getPoolSize(){

return pool.getPoolSize();

}

public ThreadPoolExecutor getPool(){

return pool;

}

/**

* 关闭线程池

*/

public void closePool() {

pool.shutdown();

}

}