任务队列ThreadPoolExecutor线程池的使用与理解
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
任务和队列
---------------------------------