PS:今天上午，非常郁闷，有很多简单基础的问题搞得我有些迷茫，哎，代码几天不写就忘。目前又不当COO，还是得用心记代码哦！
线程池的作用就是用尽可能少的线程来执行尽可能多的Runnable，以实现对线程的充分利用。
从ThreadPoolExecutor类的结构方法提及：
ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize, // 核心线程数
int maximumPoolSize, // 最大线程数
long keepAliveTime, // 生存时光
TimeUnit unit, // keepAliveTime值的度量单位
BlockingQueue<Runnable> workQueue) // 阻塞队列
我们通过ThreadPoolExecutor类的execute()方法添加我们要执行的任务。上面通过实例讲授ThreadPoolExecutor类的应用。
任务类Task：
将会被线程池执行的任务类
class Task {
public void fun() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " 执行 - " + i);
}
}
}
在创建线程池之前，我们先懂得一下BlockingQueue，在结构线程池的时候，需要为其指定一个BlockingQueue，可用于传输和保持提交的任务。可以应用此队列与池巨细进行交互。
BlockingQueue(阻塞队列):
如果运行的线程少于 corePoolSize，则 Executor一直首选添加新的线程，而不进行排队(不添加进阻塞队列)。
如果运行的线程等于或多于 corePoolSize，则 Executor 一直首选将请求参加队列，而不添加新的线程。
如果没法将请求参加队列，则创建新的线程，除非创建此线程超越 maximumPoolSize，在这类情况下，任务将被拒绝。
排队有三种通用策略：
1：直接提交
SynchronousQueue
它将任务直接提交给线程而不保存它们。在此，如果不存在可用于立即运行任务的线程，
则试图把任务参加队列将失败，因此会结构一个新的线程。此策略可以避免在处置可能具有内部依赖性的请求集时涌现锁。
直接提交平日要求无界 maximumPoolSizes 以避免拒绝新提交的任务。
当命令以超过队列所能处置的平均数连续到达时，此策略允许无界线程具有增加的可能性。
SynchronousQueue线程安全的Queue，可以寄存多少任务（但以后只允许有且只有一个任务在等待），
其中每个插入操作必须等待另一个线程的对应移除操作，也就是说A任务进入队列，B任务必须等A任务被移除之后才能进入队列，否则执行异常策略。
你来一个我扔一个，所以说SynchronousQueue没有任何内部容量。
比如：核心线程数为2，最大线程数为3；应用SynchronousQueue。
以后有2个核心线程在运行，又来了个A任务，两个核心线程没有执行完以后任务，根据如果运行的线程等于或多于 corePoolSize，
则 Executor 一直首选将请求参加队列，而不添加新的线程。所以A任务被添加到队列，此时的队列是SynchronousQueue，
以后不存在可用于立即运行任务的线程，因此会结构一个新的线程，此时又来了个B任务，两个核心线程还没有执行完。
新创建的线程正在执行A任务，所以B任务进入Queue后，最大线程数为3，发现没地方仍了。就只能执行异常策略(RejectedExecutionException)。
代码示例：
public class PoolExecutorTest {
public static void main(String[] args) {
final Task task = new Task();
ThreadPoolExecutor pool =
new ThreadPoolExecutor(2, 3, 3L,
TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 4; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
task.fun();
System.out.println("run");
}
});
}
pool.shutdown();
}
}
// 在添加第4个任务的时候，程序抛出 java.util.concurrent.RejectedExecutionException
2：无界队列
如LinkedBlockingQueue
应用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有核心线程都在忙时新任务在队列中等待。
这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就没意义了。）也就不会有新线程被创建，都在那等着排队呢。
如果未指定容量，则它等于 Integer.MAX_VALUE。
如果设置了Queue预定义容量，则当核心线程劳碌时，新任务会在队列中等待，直到超过预定义容量(新任务没地方放了)，才会执行异常策略。
你来一个我接一个，直到我容不下你了。FIFO，先进先出。
比如：核心线程数为2，最大线程数为3；应用LinkedBlockingQueue(1)，设置容量为1。
以后有2个核心线程在运行，又来了个A任务，两个核心线程没有执行完以后任务，根据如果运行的线程等于或多于 corePoolSize，
则 Executor 一直首选将请求参加队列，而不添加新的线程。所以A任务被添加到队列，此时的队列是LinkedBlockingQueue，
此时又来了个B任务，两个核心线程没有执行完以后任务，A任务在队列中等待，队列已满。所以根据如果没法将请求参加队列，则创建新的线程，
B任务被新创建的线程所执行，此时又来个C任务，此时maximumPoolSize已满，队列已满，只能执行异常策略(RejectedExecutionException)。
代码示例：
public class PoolExecutorTest {
public static void main(String[] args) {
final Task task = new Task();
ThreadPoolExecutor pool =
new ThreadPoolExecutor(2, 3, 3L,
TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(1), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 5; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
task.fun();
System.out.println("run");
}
});
}
pool.shutdown();
}
}
// 在添加第5个任务的时候，程序抛出 java.util.concurrent.RejectedExecutionException
无界的话要避免任务增加的速度远远超过处置任务的速度。
3：有界队列
如ArrayBlockingQueue
操作模式跟LinkedBlockingQueue查不多，只不过必须为其设置容量。所以叫有界队列。
new ArrayBlockingQueue<Runnable>(Integer.MAX_VALUE) 跟 new LinkedBlockingQueue(Integer.MAX_VALUE)效果一样。
LinkedBlockingQueue 底层是链表结构
ArrayBlockingQueue 底层是数组结构
你来一个我接一个，直到我容不下你了。FIFO，先进先出。
代码示例
：
public class PoolExecutorTest {
public static void main(String[] args) {
final Task task = new Task();
ThreadPoolExecutor pool =
new ThreadPoolExecutor(2, 3, 3L,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 5; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
task.fun();
System.out.println("run");
}
});
}
pool.shutdown();
}
}
// 在添加第5个任务的时候，程序抛出 java.util.concurrent.RejectedExecutionException
关于keepAliveTime：
JDK解释：当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时光。
也就是说啊，线程池中以后的空闲线程服务完某任务后的存活时光。如果时光充足长，那么可能会服务其它任务。
这里的空闲线程包不包括后来新创建的服务线程呢？我的理解是包括的。
关于handler有四个选择：
ThreadPoolExecutor.AbortPolicy() 抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy() 重试添加以后的任务，他会主动重复调用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy() 摈弃旧的任务
ThreadPoolExecutor.DiscardPolicy() 摈弃以后的任务
小的分析：
应用无界队列，要避免任务增加的速度远远超过处置任务的速度，控制不好可能导致的结果就是内存溢出。
应用有界队列，关键在于调节线程数和Queue巨细 ，线程数多，队列容量少，资源浪费。线程数少，队列容量多，性能低，还可能导致内存溢出。
原创文章，转载请注明出处：http://blog.csdn.net/thinking_in_android
文章结束给大家分享下程序员的一些笑话语录：
腾讯总舵主马化腾，有人曾经戏称如果在Z国选举总统，马化腾一定当选，因为只要QQ来一个弹窗”投马总，送Q币”即可。
---------------------------------
原创文章 By
任务和队列
---------------------------------