Android与线程池

Android与线程池：

在Android中会经常用非UI线程来处理耗时的逻辑，即使用线程处理异步任务，但每个线程的创建和销毁都需要一定的开销。假设每次执行一个任务都需要开一个新的线程去执行，则这些线程的创建和销毁将消耗大量的资源，并且线程都是“各自为政”，很难对其进行控制，更别说一堆线程了。为了解决这些问题就需要线程池大显身手，用线程池对线程进行管理。在Java 1.5中提供了Executor框架用于把任务的提交和执行解耦，任务的提交交给Runnable或者Callable，而Executor框架用来处理任务。Executor框架中最核心的成员就是ThreadPoolExecutor,它是线程的核心实现类。

---

线程池的优势：

1. 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
2. 提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
3. 方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。
4. 提供更强大的功能，延时定时线程池。

---

ThreadPoolExecutor:

可以通过ThreadPoolExecutor来创建一个线程池，ThreadPoolExecutor类一共有4个构造方法。其中，拥有最多参数的构造方法：

public ThreadPoolExecutor(int corePoolSize,
											int maximumPoolSize,
											long keepAliveTime,
											TimeUnit unit,
											BlockingQueue workQueue,
											ThreadFactory threadFactory,
											RejectedExecutionHandler handler){
				…………
	}

参数说明：

• corePoolSize：核心线程数。默认情况下线程池是空的，只是任务提交时才会创建线程。如果当前运行的线程数少于corePoolSize，则会创建新线程来处理任务；如果等于或者等于corePoolSize,则不再创建。如果调用线程池的prestartAllcoreThread方法，线程池会提前创建并启动所有的核心线程来等待任务。
• maximumPoolSize：线程池允许创建的最大线程数。如果任务队列满了并且线程数小于maximumPoolSize时，则线程池仍然会创建新的线程来处理任务。
• keepAliveTime：非核心线程闲置的超时事件。超过这个事件则回收。如果任务很多，并且每个任务的执行时间很短，则可以调大keepAliveTime来提高线程的利用率。另外，如果设置allowCoreThreadTimeOut属性来true时，keepAliveTime也会应用到核心线程上。
• TimeUnit：keepAliveTime参数的时间单位。可选的单位有天Days、小时HOURS、分钟MINUTES、秒SECONDS、毫秒MILLISECONDS等。
• workQueue：任务队列。如果当前线程数大于corePoolSzie，则将任务添加到此任务队列中。该任务队列是BlockingQueue类型的，即阻塞队列（阻塞队列在另一篇博文中会提到）。
• ThreadFactory：线程工厂。可以使用线程工厂给每个创建出来的线程设置名字。一般情况下无须设置该参数。
• RejectedExecutionHandler：饱和策略。这是当前任务队列和线程池都满了时所采取的应对策略，默认是AbordPolicy，表示无法处理新任务，并抛出RejectedExecutionException异常。

RejectedExecutionHandler:饱和策略（共4种）：
1.AbordPolicy:无法处理新任务，并抛出RejectedExecutionException异常。
2.CallerRunsPolicy:用调用者所在的线程来处理任务。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
3.DiscardPolicy：不能执行的任务，并将该任务删除。
4.DiscardOldestPolicy:丢弃队列最近的任务，并执行当前的任务。

---

线程池的处理流程和原理：

线程池的原理，当提交一个新的任务到线程池时，线程池的处理流程如下：

由图分析，线程的处理流程主要分为3个步骤：

1. 提交任务后，线程池先判断线程数是否达到了核心线程数corePoolSize。如果未达到核心线程数，则创建核心线程处理任务，否则，就执行下一步判断。
2. 接着线程池判断任务队列是否满了。如果没满，则将任务添加到任务队列中，否则，就执行下一步操作。
3. 最后因为任务队列满了，线程池就判断线程数是否达到了最大线程数。如果未达到，则创建非核心线程处理任务，否则，就执行饱和策略，默认会抛出RejectedeException异常。

线程池执行示意图，如下：

执行ThreadPoolExcutor的execute方法，可能会遇到以下情况：

1. 如果线程池中的线程数未达到核心线程数，则创建核心线程处理任务。
2. 如果线程数大于或者等于核心线程数，则将任务加入任务队列中，线程池中的空闲线程会不断的从任务队列中取出任务进行处理。
3. 如果任务队列满了，并且线程数没有达到最大线程数，则创建非核心线程去处理任务。
4. 如果线程数超过了最大线程数，则执行上面提到的几种饱和策略。

---

线程池的种类：

通过直接或间接的配置ThreadPoolExecutor的参数可以创建不同类型的ThreadPoolExecutor，其中有4种线程池比较常用：FixedThreadPool、CachedThreadPool、SingleThreadExecutor、ScheduledTheadPool。

1. FixedThreadPool：
   FixedThreadPool是可重用固定线程数的线程池。在Executors类中提供了创建FixedThreadPool的方法：

public static ExecutorService newFixedThreadPool(int nThreads){
	return new ThreadPoolExecutor(nThreads,nThreads,
														0L,TimeUnit.MILLISECONDS,
														new LinkedBlockingQueue());
}

FixedThreadPool的corePoolSize和maximumPoolSize都设置为创建FixedThreadPool指定的参数nThreads，意味着FixedThreadPool只有核心线程，并且数量是固定的，没有非核心线程。keepAliveTime设置为0L，意味着多余的线程会被立即终止。因为不会产生多余的线程，所以KeepAliveTime是无效的参数。任务队列采用了无界的阻塞队列LinkedBlockingQueue。FixedThreadPool的execute方法执行图如下：

由图分析可知：
当执行execute方法时，如果当前运行的线程未达到corePoolSize(核心线程数)时就创建核心线程来处理任务，如果达到了核心线程数则将任务添加到LinkedBlockingQueue中。FixedThreadPool就是一个有固定数量核心线程的线程池，并且这些核心线程不会被回收。当线程超过corePoolSize时，就将任务存储在任务队列中。当线程池有空闲线程时，则从任务队列中去取任务执行。

2. CachedThreadPool:
   CachedThreadPool是一个根据需要创建线程的线程池。
   创建CachedThreadPool代码：

public static ExecutorService newCachedThreadPool(){
	return new ThreadPoolExecutor(0,Integer.MAX_VALUE,
														60L,TimeUnit.SECONDS,
														new SynchronousQueue());
}

CachedThreadPool的corePoolSize为0，maximumPoolSize设置为Integer.MAX_VALUE，意味着CachedThreadPool没有核心线程，非核心线程是无界的。KeepAliveTime设置为60L，则空闲线程等待新任务的最长时间为60s。在此用了阻塞队列SynchronousQueue，它是一个不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作，同样任何一个移除操作都等待另一个线程的插入操作。
CachedThreadPool的execute方法的执行示意图，如下：

由图分析可知，当执行execute方法时，首先会执行SynchronousQueue的offer方法来提交任务，并查询线程池中是否有空闲的线程执行SynchronousQueue的poll方法来移除任务。如果有则配对成功，将任务交给这个空闲的线程处理。如果没有则配对失败，创建新的线程去处理任务。当线程池中的线程空闲时，它会执行SynchronousQueue的poll方法，等待SynchronousQueue中新提交的任务。如果超过了60s没有新任务提交到SynchronousQueue，则这个空间线程将终止。因为maximumPoolSize是无界的，所以如果提交的任务大于线程池中线程处理任务的速度就会不断的创建新线程。另外，每次提交任务都会立即有线程去处理。所以，CachedThreadPool比较适于大量的需要立即处理并且耗时较少的任务。

3. SingleThreadExecutor:
   SingleThreadExecutor是使用单个工作线程的线程池，其创建代码如下：

public static ExecutorService newSingleThreadExecutor{
	return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1,1,
																					0L,TimeUnit.MILLISECONDS,
																					new LinkedBlockingQueue()));
}

corePoolSize和maximumPoolSize都为1，意味着SingleThreadExecutor只有一个核心线程，其他的参数都和FixedThreadPool一样。
SingleThreadExecutor的execute方法执行示意图：

由图分析，可知：
当执行execute方法时，如果当前运行的线程数未达到核心线程数，也就是当前没有运行的线程，则创建一个新线程来处理任务。如果当前有运行的线程，则将任务添加到阻塞队列LinkedBlockingQueue中。因此，SingleThreadExecutor能确保所有的任务在一个线程中按照顺序逐一执行。

4. ScheduledThreadPool:
   ScheduledThreadPool是一个能实现定时和周期性任务的线程池。创建代码如下：

public staic ScheduledExecutorService newScheduledThreadPool(int corePoolSize){
	return new ScheduledThreadPoolExecutor(corePoolSize);
}

这里创建了ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，它主要用于给定延时以后运行的任务或者定期处理任务。ScheduledThreadPoolExecutor的构造方法如下：

public ScheduledThreadPoolExecutor(int corePoolSize){
	super(corePoolSize,Integer.MAX_VALUE,
				DEFAULT_KEEPALIVE_MILLIS,MILLISECONDS,
				new DelayedWorkQueue());
}

ScheduledThreadPoolExecutor的构造方法最终调用的是ThreadPoolExecutor的构造方法。corePoolSize是传进来的固定数值，maximumPoolSize的值是Integer.MAX_VALUE。因为采用的DelayedWorkQueue是无界的，所以maximumPoolSize这个参数是无效的。
ScheduledThreadPoolExecutor的execute方法的执行示意图如下：

由图分析，可知：
当执行ScheduledThreadPoolExecutor的scheduleAtFixedRate或者scheduleWithFixDelay方法时，会向DelayedWorkQueue添加一个实现RunnableScheduledFuture接口的ScheduledFutureTask（任务的包装类），并会检查运行的线程是否达到corePoolSize。如果没有则新建线程并启动它，但不是立即去执行任务，而是去DelayedWorkQueue中取出ScheduledFutureTask,然后去执行任务。如果运行的线程达到了corePoolSize时，则将任务添加到DelayedWorkQueue中。DelayedWorkQueue会将任务进行排序，先要执行的任务放在队列的前面。其和上面介绍的几个线程池不同的是，当执行完任务后，会将ScheduledFutureTask的time变量改为下次要执行的时间并放回到DelayedWorkQueue中。

---

线程池中关于队列的疑问：

线程池为什么要用（阻塞）队列？

1. 因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换。
2. 创建线程池的消耗较高。线程池创建线程需要获取mainlock这个全局锁，影响并发效率，阻塞队列可以很好的缓冲。

线程池为什么要使用阻塞队列而不使用非阻塞队列？
阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。当队列中有任务时才唤醒对应线程从队列中取出消息进行执行。使得在线程不至于一直占用cpu资源。

线程执行完任务后通过循环再次从任务队列中取出任务进行执行，代码片段如下

while (task != null || (task = getTask()) != null) {}）。

不用阻塞队列也是可以的，不过实现起来比较麻烦而已，有好用的为啥不用呢？

---

如何配置线程池：

• CPU密集型任务：
  尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。
• IO密集型任务：
  可以使用稍大的线程池，一般为2*CPU核心数。 IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。
• 混合型任务：
  可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。 只要分完之后两个任务的执行时间相差不大，那么就会比串行执行来的高效。因为如果划分之后两个任务执行时间有数据级的差距，那么拆分没有意义。因为先执行完的任务就要等后执行完的任务，最终的时间仍然取决于后执行完的任务，而且还要加上任务拆分与合并的开销，得不偿失。

---

execute()和submit()方法：

1. execute()，执行一个任务，没有返回值。
2. submit()，提交一个线程任务，有返回值。

submit(Callable task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用（IntentService中有体现）。
submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。
submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null。

---

注：Android中的AsyncTask就用到了线程，而线程池用到了阻塞队列。（关于AsyncTask的原理和阻塞队列在另外2篇博文中会提到）。