任务队列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
任务和队列
---------------------------------

posted @ 2013-05-26 23:13  xinyuyuanm  阅读(718)  评论(0编辑  收藏  举报