- 浏览: 382408 次
- 性别:
- 来自: 印度
文章分类
最新评论
-
天天来注册:
...
多线程的死锁 -
memoryisking:
可以看看这篇文章,这个是struts教程网上一个简单的例子,构 ...
Java5中的线程池实例讲解 -
a123159521:
菜鸟不再菜 写道楼主很明显没有说明守护线程到底是怎么服务Use ...
守护线程总结 -
jjruanlili:
要搞个executor和nio的结合,差不多
Java5中的线程池实例讲解 -
josico:
纠正楼主一个问题‘如果四个队员都在忙时,再有新的任务,这个小组 ...
线程池ThreadPoolExecutor使用简介
一、简介
线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
corePoolSize: 线程池维护线程的最少数量
maximumPoolSize:线程池维护线程的最大数量
keepAliveTime: 线程池维护线程所允许的空闲时间
unit: 线程池维护线程所允许的空闲时间的单位
workQueue: 线程池所使用的缓冲队列
handler: 线程池对拒绝任务的处理策略
一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法。
当一个任务通过execute(Runnable)方法欲添加到线程池时:
如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。
也就是:处理任务的优先级为:
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性:
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常用的是:java.util.concurrent.ArrayBlockingQueue
handler有四个选择:
ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务,他会自动重复调用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务
二、一般用法举例
说明:
1、在这段程序中,一个任务就是一个Runnable类型的对象,也就是一个ThreadPoolTask类型的对象。
2、一般来说任务除了处理方式外,还需要处理的数据,处理的数据通过构造方法传给任务。
3、在这段程序中,main()方法相当于一个残忍的领导,他派发出许多任务,丢给一个叫 threadPool的任劳任怨的小组来做。
这个小组里面队员至少有两个,如果他们两个忙不过来,任务就被放到任务列表里面。
如果积压的任务过多,多到任务列表都装不下(超过3个)的时候,就雇佣新的队员来帮忙。但是基于成本的考虑,不能雇佣太多的队员,至多只能雇佣 4个。
如果四个队员都在忙时,再有新的任务,这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发,直到接受这个任务为止(更残忍!呵呵)。
因为队员工作是需要成本的,如果工作很闲,闲到 3SECONDS都没有新的任务了,那么有的队员就会被解雇了,但是,为了小组的正常运转,即使工作再闲,小组的队员也不能少于两个。
4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制,改变这两个值就可以观察不同速率下程序的工作情况。
5、通过调整4中所指的数据,再加上调整任务丢弃策略,换上其他三种策略,就可以看出不同策略下的不同处理方式。
6、对于其他的使用方法,参看jdk的帮助,很容易理解和使用。
另一个例子:
应该是没写pool.shutdown(),才导致进程一直不结束
现在又有一个新的问题
pool的execute方法,可以看做是把线程丢到线程池里面来控制并且执行,也就是说他承担了2个任务,那我现在是有若干个线程我已经知道要用了,但是现在不用,等到未来某个时候我传个参数,让这些线程池里的线程跑起来,这样可以吗?就是装载和运行,分两步。应该是可以的吧,这也符合单一职责原则
PS.楼主对参数的比喻真的很赞哟!
createThreadPool() 方法是在测试用例中调用的,测试用例不存在并发。
同认为不应该加synchronized
恩,主要是楼主为了方便演示队列的效果,让线程一直等待,如果把
# while (getQueueSize(tpe.getQueue()) >= queueDeep)
# {
# System.out.println("队列已满,等3秒再添加任务");
# try
# {
# Thread.sleep(3000);
# }
# catch (InterruptedException e)
# {
# e.printStackTrace();
# }
# }
这一段去了的话就是最多执行4个线程了
任务仅仅是实现了Runnable接口的对象,并不是一个线程,jdk这里的设计有误导作用
线程池的核心作用是减少创建和销毁线程对系统的开销,对线程数和并发数量进行宏观的调控
任务仅仅是实现了Runnable接口的对象,并不是一个线程,jdk这里的设计有误导作用
线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
corePoolSize: 线程池维护线程的最少数量
maximumPoolSize:线程池维护线程的最大数量
keepAliveTime: 线程池维护线程所允许的空闲时间
unit: 线程池维护线程所允许的空闲时间的单位
workQueue: 线程池所使用的缓冲队列
handler: 线程池对拒绝任务的处理策略
一个任务通过 execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是 Runnable类型对象的run()方法。
当一个任务通过execute(Runnable)方法欲添加到线程池时:
如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。
也就是:处理任务的优先级为:
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性:
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常用的是:java.util.concurrent.ArrayBlockingQueue
handler有四个选择:
ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务,他会自动重复调用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务
二、一般用法举例
package demo; import java.io.Serializable; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThreadPool2 { private static int produceTaskSleepTime = 2; private static int produceTaskMaxNumber = 10; public static void main(String[] args) { // 构造一个线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), new ThreadPoolExecutor.DiscardOldestPolicy()); for (int i = 1; i <= produceTaskMaxNumber; i++) { try { // 产生一个任务,并将其加入到线程池 String task = "task@ " + i; System.out.println("put " + task); threadPool.execute(new ThreadPoolTask(task)); // 便于观察,等待一段时间 Thread.sleep(produceTaskSleepTime); } catch (Exception e) { e.printStackTrace(); } } } } /** * 线程池执行的任务 */ class ThreadPoolTask implements Runnable, Serializable { private static final long serialVersionUID = 0; private static int consumeTaskSleepTime = 2000; // 保存任务所需要的数据 private Object threadPoolTaskData; ThreadPoolTask(Object tasks) { this.threadPoolTaskData = tasks; } public void run() { // 处理一个任务,这里的处理方式太简单了,仅仅是一个打印语句 System.out.println(Thread.currentThread().getName()); System.out.println("start .." + threadPoolTaskData); try { // //便于观察,等待一段时间 Thread.sleep(consumeTaskSleepTime); } catch (Exception e) { e.printStackTrace(); } threadPoolTaskData = null; } public Object getTask() { return this.threadPoolTaskData; } }
说明:
1、在这段程序中,一个任务就是一个Runnable类型的对象,也就是一个ThreadPoolTask类型的对象。
2、一般来说任务除了处理方式外,还需要处理的数据,处理的数据通过构造方法传给任务。
3、在这段程序中,main()方法相当于一个残忍的领导,他派发出许多任务,丢给一个叫 threadPool的任劳任怨的小组来做。
这个小组里面队员至少有两个,如果他们两个忙不过来,任务就被放到任务列表里面。
如果积压的任务过多,多到任务列表都装不下(超过3个)的时候,就雇佣新的队员来帮忙。但是基于成本的考虑,不能雇佣太多的队员,至多只能雇佣 4个。
如果四个队员都在忙时,再有新的任务,这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发,直到接受这个任务为止(更残忍!呵呵)。
因为队员工作是需要成本的,如果工作很闲,闲到 3SECONDS都没有新的任务了,那么有的队员就会被解雇了,但是,为了小组的正常运转,即使工作再闲,小组的队员也不能少于两个。
4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制,改变这两个值就可以观察不同速率下程序的工作情况。
5、通过调整4中所指的数据,再加上调整任务丢弃策略,换上其他三种策略,就可以看出不同策略下的不同处理方式。
6、对于其他的使用方法,参看jdk的帮助,很容易理解和使用。
另一个例子:
package demo; import java.util.Queue; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ThreadPoolExecutorTest { private static int queueDeep = 4; public void createThreadPool() { /* * 创建线程池,最小线程数为2,最大线程数为4,线程池维护线程的空闲时间为3秒, * 使用队列深度为4的有界队列,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除, * 然后重试执行程序(如果再次失败,则重复此过程),里面已经根据队列深度对任务加载进行了控制。 */ ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep), new ThreadPoolExecutor.DiscardOldestPolicy()); // 向线程池中添加 10 个任务 for (int i = 0; i < 10; i++) { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } while (getQueueSize(tpe.getQueue()) >= queueDeep) { System.out.println("队列已满,等3秒再添加任务"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } TaskThreadPool ttp = new TaskThreadPool(i); System.out.println("put i:" + i); tpe.execute(ttp); } tpe.shutdown(); } private synchronized int getQueueSize(Queue queue) { return queue.size(); } public static void main(String[] args) { ThreadPoolExecutorTest test = new ThreadPoolExecutorTest(); test.createThreadPool(); } class TaskThreadPool implements Runnable { private int index; public TaskThreadPool(int index) { this.index = index; } public void run() { System.out.println(Thread.currentThread() + " index:" + index); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
评论
11 楼
josico
2014-04-24
纠正楼主一个问题
‘如果四个队员都在忙时,再有新的任务,这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发,直到接受这个任务为止’
你的handler选的是DiscardOldestPolicy,丢弃最早的那个任务,而非不停的派发。
应该是,如果线程数已经到了max,而queue也满了的情况下,按照这个策略,那就会丢弃queue中的第一个任务
‘如果四个队员都在忙时,再有新的任务,这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发,直到接受这个任务为止’
你的handler选的是DiscardOldestPolicy,丢弃最早的那个任务,而非不停的派发。
应该是,如果线程数已经到了max,而queue也满了的情况下,按照这个策略,那就会丢弃queue中的第一个任务
10 楼
josico
2014-04-24
josico 写道
楼主写的第一个例子貌似死锁了 程序一致跑不完
目前在看原因
目前在看原因
应该是没写pool.shutdown(),才导致进程一直不结束
现在又有一个新的问题
pool的execute方法,可以看做是把线程丢到线程池里面来控制并且执行,也就是说他承担了2个任务,那我现在是有若干个线程我已经知道要用了,但是现在不用,等到未来某个时候我传个参数,让这些线程池里的线程跑起来,这样可以吗?就是装载和运行,分两步。应该是可以的吧,这也符合单一职责原则
PS.楼主对参数的比喻真的很赞哟!
9 楼
josico
2014-04-24
楼主写的第一个例子貌似死锁了 程序一致跑不完
目前在看原因
目前在看原因
8 楼
rbible
2014-02-25
sunwang810812 写道
楼主能不能解释一下,代码2中,为什么方法getQueueSize要加synchronized,这个方法里又没有操作类的属性,这个不会引起线程安全问题吧,怎么还要加锁呢?
createThreadPool() 方法是在测试用例中调用的,测试用例不存在并发。
同认为不应该加synchronized
7 楼
sunwang810812
2013-06-14
楼主能不能解释一下,代码2中,为什么方法getQueueSize要加synchronized,这个方法里又没有操作类的属性,这个不会引起线程安全问题吧,怎么还要加锁呢?
6 楼
付绍高
2013-03-04
受教了!!
5 楼
zy116494718
2012-11-14
1041367971 写道
楼主写的第二个例子,好像永远只能执行2个县城,最大线程数没有任何作用了!
恩,主要是楼主为了方便演示队列的效果,让线程一直等待,如果把
# while (getQueueSize(tpe.getQueue()) >= queueDeep)
# {
# System.out.println("队列已满,等3秒再添加任务");
# try
# {
# Thread.sleep(3000);
# }
# catch (InterruptedException e)
# {
# e.printStackTrace();
# }
# }
这一段去了的话就是最多执行4个线程了
4 楼
1041367971
2012-10-22
楼主写的第二个例子,好像永远只能执行2个县城,最大线程数没有任何作用了!
3 楼
beitown
2012-09-13
coach 写道
Sweblish 写道
每一个任务都是一个线程,那么线程池的作用在哪里呢?
线程池的作用是:减少生成的对象的个数,这里每个任务都是一个线程,那么没有体现线程池的作用啊?
求解释!
线程池的作用是:减少生成的对象的个数,这里每个任务都是一个线程,那么没有体现线程池的作用啊?
求解释!
任务仅仅是实现了Runnable接口的对象,并不是一个线程,jdk这里的设计有误导作用
线程池的核心作用是减少创建和销毁线程对系统的开销,对线程数和并发数量进行宏观的调控
2 楼
coach
2012-08-06
Sweblish 写道
每一个任务都是一个线程,那么线程池的作用在哪里呢?
线程池的作用是:减少生成的对象的个数,这里每个任务都是一个线程,那么没有体现线程池的作用啊?
求解释!
线程池的作用是:减少生成的对象的个数,这里每个任务都是一个线程,那么没有体现线程池的作用啊?
求解释!
任务仅仅是实现了Runnable接口的对象,并不是一个线程,jdk这里的设计有误导作用
1 楼
Sweblish
2012-08-04
每一个任务都是一个线程,那么线程池的作用在哪里呢?
线程池的作用是:减少生成的对象的个数,这里每个任务都是一个线程,那么没有体现线程池的作用啊?
求解释!
线程池的作用是:减少生成的对象的个数,这里每个任务都是一个线程,那么没有体现线程池的作用啊?
求解释!
发表评论
-
根据cpu情况决定线程运行数量和情况
2012-07-11 10:24 3984一个线程分配器,根据cpu的负载情况,自动完成对应线程的唤醒或 ... -
线程池shutdown
2011-06-10 14:28 5973写一个程序要求主线程等待子线程运行结束后退出,且子线程同时运行 ... -
利用lock中断线程
2011-01-13 22:53 1329ReentrantLock 的lock机制有2种,忽略中断锁和 ... -
Java5中的线程池实例讲解
2010-12-30 16:23 15622Java5增加了新的类库并发集java.util.concur ... -
Web应用程序中调度器的启动和关闭问题
2010-12-29 16:30 6822我们知道静态变量是ClassLoader级别的,如果Web应用 ... -
守护线程总结
2010-12-29 11:40 24398在Java中有两类线程:User Thread(用户线程)、D ... -
由生产者/消费者问题看JAVA多线程
2010-08-20 16:41 1596生产者消费者问题是研究多线程程序时绕不开的问题,它 ... -
Java线程:并发协作-生产者消费者模型
2010-08-20 14:37 1028对于多线程程序来说,不管任何编程语言,生产者和消费者模型都 ... -
Java线程:新特征-有返回值的线程
2010-08-20 14:31 1347在Java5之前,线程是没有返回值的,常常为了“有”返回值 ... -
Java线程:新特征-线程池
2010-08-20 14:27 15631Sun在Java5中,对Java线程的类库做了大量的扩展,其中 ... -
Java线程控制权源代码解析
2010-08-20 12:28 1529Java线程控制权的问题十分重要,我们在不断的学习中需要 ... -
详细介绍Java信号量模型实际应用手册
2010-08-20 12:26 1713Java信号量模型需要我们不断的进行学习,在学习的时候会有不 ... -
Java多线程中wait语句的具体使用技巧
2010-08-20 12:24 1818Java多线程在使用的时候 ... -
多线程的死锁
2010-08-19 16:57 2021俗话说,人多好办事!在程序里也是这样,如果是同一个应用程序需要 ... -
线程优先级
2010-07-26 00:15 2136当程序中有多个线程存 ... -
java阻塞队列
2010-07-25 23:14 1306package com.faramita.test.mians ...
相关推荐
线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor...
今天小编就为大家分享一篇关于线程池ThreadPoolExecutor使用简介与方法实例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
1.资源简介:PyQt5中使用多线程模块QThread解决了PyQt5界面程序执行比较耗时操作时,程序卡顿出现的无响应以及界面输出无法实时显示的问题,采用线程池ThreadPoolExecutor解决了ping多个IP多任务耗时问题。...
在《阿里巴巴java开发手册》中...另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现,使用ThreadPoolExecutor有助于大家明确线程池的运行规则,创建符合自己的业务场景需要的线程池,避免资源耗尽的风险。
11-线程池 ThreadPoolExecutor 底层原理源码分析(上)-周瑜.pdf 12-线程池 ThreadPoolExecutor底层原理源码分析(下)-周瑜.pdf 13、线程池 ForkJoinPool实战及其工作原理分析 (1).pdf 14、深入理解井发可见性、...
11-线程池 ThreadPoolExecutor 底层原理源码分析(上)-周瑜.pdf 12-线程池 ThreadPoolExecutor底层原理源码分析(下)-周瑜.pdf 13、线程池 ForkJoinPool实战及其工作原理分析 (1).pdf 14、深入理解井发可见性、...
线程池ThreadPoolExecutor底层原理源码分析
线程池ThreadPoolExecutor实战及其原理分析(上)
在开发过程中,合理地使用线程池能够带来3个好处: 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗; 提高响应速度。 当任务到达时,任务可以不需要等到线程创建就能立即执行; 提高...
Java,线程池,ThreadPoolExecutor
JDK1[1].5中的线程池(ThreadPoolExecutor)使用简介
Reference: 《创建Java线程池》[1],《Java线程:新特征-线程池》[2], 《Java线程池学习》[3],《线程池ThreadPoolExecutor使用简介》[4],《Java5中的线程池实例讲解》[5],《ThreadPoolExecutor使用和思考》[6] ...
今天小编就为大家分享一篇关于Android之线程池ThreadPoolExecutor的简介,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
ThreadPoolExecutor的使用和Android常见的4种线程池使用介绍
从Python3.2开始,标准库为我们提供了 concurrent.futures 模块,它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块,该模块通过 submit 返回的是一个 future ...
NULL 博文链接:https://happysoul.iteye.com/blog/1117090
最代码,http://www.zuidaima.com/share/1724478138158080.htm 的代码及例子
主要介绍了Java线程池ThreadPoolExecutor原理及使用实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
今天小编就为大家分享一篇关于Spring线程池ThreadPoolExecutor配置并且得到任务执行的结果,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧