- 浏览: 386970 次
- 性别:
- 来自: 印度
文章分类
最新评论
-
天天来注册:
...
多线程的死锁 -
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 4029一个线程分配器,根据cpu的负载情况,自动完成对应线程的唤醒或 ... -
线程池shutdown
2011-06-10 14:28 6013写一个程序要求主线程等待子线程运行结束后退出,且子线程同时运行 ... -
利用lock中断线程
2011-01-13 22:53 1371ReentrantLock 的lock机制有2种,忽略中断锁和 ... -
Java5中的线程池实例讲解
2010-12-30 16:23 15694Java5增加了新的类库并发集java.util.concur ... -
Web应用程序中调度器的启动和关闭问题
2010-12-29 16:30 6882我们知道静态变量是ClassLoader级别的,如果Web应用 ... -
守护线程总结
2010-12-29 11:40 24463在Java中有两类线程:User Thread(用户线程)、D ... -
由生产者/消费者问题看JAVA多线程
2010-08-20 16:41 1632生产者消费者问题是研究多线程程序时绕不开的问题,它 ... -
Java线程:并发协作-生产者消费者模型
2010-08-20 14:37 1065对于多线程程序来说,不管任何编程语言,生产者和消费者模型都 ... -
Java线程:新特征-有返回值的线程
2010-08-20 14:31 1384在Java5之前,线程是没有返回值的,常常为了“有”返回值 ... -
Java线程:新特征-线程池
2010-08-20 14:27 15672Sun在Java5中,对Java线程的类库做了大量的扩展,其中 ... -
Java线程控制权源代码解析
2010-08-20 12:28 1570Java线程控制权的问题十分重要,我们在不断的学习中需要 ... -
详细介绍Java信号量模型实际应用手册
2010-08-20 12:26 1760Java信号量模型需要我们不断的进行学习,在学习的时候会有不 ... -
Java多线程中wait语句的具体使用技巧
2010-08-20 12:24 1868Java多线程在使用的时候 ... -
多线程的死锁
2010-08-19 16:57 2055俗话说,人多好办事!在程序里也是这样,如果是同一个应用程序需要 ... -
线程优先级
2010-07-26 00:15 2187当程序中有多个线程存 ... -
java阻塞队列
2010-07-25 23:14 1349package com.faramita.test.mians ...
相关推荐
线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor...
线程池ThreadPoolExecutor使用简介与方法实例 线程池ThreadPoolExecutor是Java并发编程中一个非常重要的概念,它允许开发者将任务提交给线程池,并由线程池来管理这些任务的执行。今天,我们将对线程池...
1.资源简介:PyQt5中使用多线程模块QThread解决了PyQt5界面程序执行比较耗时操作时,程序卡顿出现的无响应以及界面输出无法实时显示的问题,采用线程池ThreadPoolExecutor解决了ping多个IP多任务耗时问题。...
线程池ThreadPoolExecutor底层原理源码分析
创建线程池使用`ThreadPoolExecutor`构造函数,其参数含义如下: - `corePoolSize`: 核心线程数,表示线程池中保持的最小线程数。 - `maximumPoolSize`: 最大线程数,定义了线程池允许的最大并发线程数。 - `...
线程池ThreadPoolExecutor实战及其原理分析(上)
在《阿里巴巴java开发手册》中...另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现,使用ThreadPoolExecutor有助于大家明确线程池的运行规则,创建符合自己的业务场景需要的线程池,避免资源耗尽的风险。
ThreadPoolExecutor的使用和Android常见的4种线程池使用介绍
本文将详细讲解如何使用Java中的`ThreadPoolExecutor`来抓取论坛帖子列表,结合源码分析和实用工具的应用。 首先,我们要了解线程池的基本原理。线程池是由一组预先创建的线程组成的,这些线程可以复用,而不是每次...
这个类是Spring对Java内置的`java.util.concurrent.ThreadPoolExecutor`的封装,允许开发者在Spring应用上下文中声明式地定义线程池。在本篇文章中,我们将深入探讨`ThreadPoolTaskExecutor`的配置及其使用,并结合`...
JDK1[1].5中的线程池(ThreadPoolExecutor)使用简介
从Python3.2开始,标准库为我们提供了 concurrent.futures 模块,它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块,该模块通过 submit 返回的是一个 future ...
Android之线程池ThreadPoolExecutor的简介 Android之线程池ThreadPoolExecutor是Android中一个非常重要的组件,它解决了单线程下载数据的效率慢和线程阻塞的问题。ThreadPoolExecutor的应用也是优化实现的方式,它...
线程池作为 Java 并发编程中的重要组件,在实际应用中被广泛使用。其核心类 `ThreadPoolExecutor` 实现了对线程的管理、调度等功能。本文将围绕 `ThreadPoolExecutor` 的核心方法 `execute()` 进行深入解析,帮助...
根据提供的文件信息,我们可以深入探讨线程池`ThreadPoolExecutor`的工作原理及其实现细节,同时也会涉及并发编程中的一些关键概念和技术。 ### 线程池`ThreadPoolExecutor`概述 `ThreadPoolExecutor`是Java中非常...
根据给定文件的信息,我们可以深入探讨Java中`ThreadPoolExecutor`线程池的底层实现原理,特别是其核心数据结构`ctl`以及线程池的各种状态转换。以下是对这些知识点的详细解释: ### 一、线程池`ThreadPoolExecutor...
Java 线程池例子 ThreadPoolExecutor Java 中的线程池是指一个容器,里面包含了多个线程,这些线程可以重复使用,以避免频繁创建和销毁线程的开销。ThreadPoolExecutor 是 Java 中一个非常重要的线程池实现类,它...
Java线程池ThreadPoolExecutor原理及使用实例 Java线程池ThreadPoolExecutor是Java并发编程中的一种基本机制,主要用于管理和执行任务的线程池。下面对其原理和使用实例进行详细介绍。 线程池概述 线程池是一个...
Spring线程池ThreadPoolExecutor配置并且得到任务执行的结果 在Java中,线程池是一种非常重要的技术,能够帮助我们更好地管理线程资源,提高系统的性能和可扩展性。其中,ThreadPoolExecutor是Java中的一种线程池...