- 浏览: 364513 次
- 性别:
- 来自: Alien
文章分类
最新评论
-
风一样的男人__:
[flash=200,200][url]引用[/url][/f ...
java线程内存模型,线程、工作内存、主内存 -
极乐君:
厉害了,,,请问可以转载到我们专栏吗?会注明来源和地址的~专栏 ...
java线程内存模型,线程、工作内存、主内存 -
zdd001:
Spring 线程池使用 -
zdd001:
Spring 线程池使用 -
u014663756:
看了三行就知道是我想要的!!
java线程内存模型,线程、工作内存、主内存
Spring 线程池使用
/**
*
*/
一个日志管理的类:
在批理更新,插入,等操作
package com.xiu.order.core.orders.impl;
import java.util.List;
import org.springframework.core.task.TaskExecutor;
import com.xiu.common.dao.persistence.exception.DAOException;
import com.xiu.order.core.exception.ManagerException;
import com.xiu.order.core.orders.LogManager;
import com.xiu.order.dal.orders.dao.LogDAO;
import com.xiu.order.dal.orders.dataobject.LogDO;
public class LogManagerImpl implements LogManager {
private LogDAO operatorLogDAO;
public LogDAO getOperatorLogDAO() {
return operatorLogDAO;
}
public void setOperatorLogDAO(LogDAO operatorLogDAO) {
this.operatorLogDAO = operatorLogDAO;
}
private TaskExecutor taskExecutor;
public void setTaskExecutor(TaskExecutor taskExecutor) {
this.taskExecutor = taskExecutor;
}
@Override
public List<LogDO> queryOperatorLog(int orderId) throws ManagerException {
try {
return operatorLogDAO.queryOperatorLog(orderId);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
@Override
public int insertOperatorLog(LogDO operationLogDO) throws ManagerException {
try {
return operatorLogDAO.insertOperatorLog(operationLogDO);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
@Override
public List<LogDO> queryOperatorLogList(LogDO operationLogDO)
throws ManagerException {
try {
return operatorLogDAO.queryOperatorLogList(operationLogDO);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
public void batchAddOptLogAsync(final List<LogDO> optLogDOList)
throws ManagerException {
taskExecutor.execute(new Runnable() {
public void run() {
try {
operatorLogDAO.batchAddOptLogAsync(optLogDOList);
} catch (DAOException e) {
// System.out.println(e);
}
}
});
}
@Override
public void addOptLogAsync(final LogDO optLogDO) throws ManagerException {
taskExecutor.execute(new Runnable() {
public void run() {
try {
insertOperatorLog(optLogDO);
} catch (ManagerException e) {
e.printStackTrace();
}
}
});
}
@Override
public List<Integer> queryLogInfoByOrderIdListAndLogInfo(
List<Integer> orderIdList, LogDO oprationLogDO)
throws ManagerException {
try {
return operatorLogDAO.queryLogInfoByOrderIdListAndLogInfo(
orderIdList, oprationLogDO);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
}
spring 配置
<bean id="operatorLogManager" class="com.xiu.order.core.orders.impl.LogManagerImpl ">
<property name="taskExecutor" ref="taskExecutor"></property>
</bean>
<bean id="taskExecutor"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="30" />
</bean>
<转>
最近,由于项目里需要用到线程池来提高处理速度,记录一下spring的taskExecutor执行器来实现线程池。
这里省略了Service接口的定义和在applicationContext.xml文件中配置相应的bean(service)。
1、处理器实现类
Java代码
1.package com.shine.job;
2.
3.import java.util.List;
4.
5.import org.apache.commons.logging.Log;
6.import org.apache.commons.logging.LogFactory;
7.import org.springframework.core.task.TaskExecutor;
8.
9.import com.shine.service.Service;
10.
11./**
12. * 处理器接口实现类
13. */
14.public class ProcessorImpl implements Processor {
15.
16. // 日志对象
17. private static Log logger = LogFactory.getLog(ProcessorImpl.class);
18.
19. // 执行器
20. private TaskExecutor taskExecutor;
21.
22. // 业务接口
23. private Service service;
24.
25. public void process() {
26. // 使用多线程处理
27. taskExecutor.execute(new Runnable(){
28. public void run() {
29. try {
30. logger.debug("[Thread "
31. + Thread.currentThread().getId()
32. + " start]");
33. // 业务处理
34. service.handle(name);
35. logger.debug("[Thread "
36. + Thread.currentThread().getId()
37. + " end]");
38. } catch (RuntimeException e) {
39. logger.error("Service handle exception",e);
40. }
41. }
42. });
43. }
44. }
45.
46. public void setService(Service service) {
47. this.service = service;
48. }
49.
50. public void setTaskExecutor(TaskExecutor taskExecutor) {
51. this.taskExecutor = taskExecutor;
52. }
53.
54.}
2、applicationContext.xml配置
Xml代码
1.<!-- 线程池(执行器) -->
2.<task:executor id="taskExecutor" pool-size="1-4" queue-capacity="128" />
3.
4.<!-- 处理接口 -->
5.<bean id="processor" class="com.shine.job.ProcessorImpl">
6. <property name="service" ref="service" />
7. <property name="taskExecutor">
8. <ref bean="taskExecutor" />
9. </property>
10.</bean>
其中:
pool-size="1-4",表示线程池活跃的线程数为1,最大线程数为4;
queue-capacity="128",表示任务队列的最大容量。
PS:关于taskExecutor还有一种配置bean来实现的,其配置的写法和参数与上面基本一致。
ThreadPoolTaskExecutor的配置在网上找了很多解释没找到,看了下ThreadPoolExecutor的配置,名字差不多,应该含义也差不多。只不过ThreadPoolTaskExecutor对
ThreadPoolExecutor做了包装。
<bean id ="taskExecutor" class ="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" >
<property name ="corePoolSize" value ="5" />
<property name ="keepAliveSeconds" value ="300" />
<property name ="maxPoolSize" value ="10" />
<property name ="queueCapacity" value ="25" />
</bean> 线程的配置文件:
corePoolSize: 线程池维护线程的最少数量
keepAliveSeconds 线程池维护线程所允许的空闲时间
maxPoolSize 线程池维护线程的最大数量
queueCapacity 线程池所使用的缓冲队列
当一个任务通过execute(Runnable)方法欲添加到线程池时:
l 如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
l 如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
l 如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
l 如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。也就是:处理任务的优先级为:核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
l 当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
/**
*
*/
一个日志管理的类:
在批理更新,插入,等操作
package com.xiu.order.core.orders.impl;
import java.util.List;
import org.springframework.core.task.TaskExecutor;
import com.xiu.common.dao.persistence.exception.DAOException;
import com.xiu.order.core.exception.ManagerException;
import com.xiu.order.core.orders.LogManager;
import com.xiu.order.dal.orders.dao.LogDAO;
import com.xiu.order.dal.orders.dataobject.LogDO;
public class LogManagerImpl implements LogManager {
private LogDAO operatorLogDAO;
public LogDAO getOperatorLogDAO() {
return operatorLogDAO;
}
public void setOperatorLogDAO(LogDAO operatorLogDAO) {
this.operatorLogDAO = operatorLogDAO;
}
private TaskExecutor taskExecutor;
public void setTaskExecutor(TaskExecutor taskExecutor) {
this.taskExecutor = taskExecutor;
}
@Override
public List<LogDO> queryOperatorLog(int orderId) throws ManagerException {
try {
return operatorLogDAO.queryOperatorLog(orderId);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
@Override
public int insertOperatorLog(LogDO operationLogDO) throws ManagerException {
try {
return operatorLogDAO.insertOperatorLog(operationLogDO);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
@Override
public List<LogDO> queryOperatorLogList(LogDO operationLogDO)
throws ManagerException {
try {
return operatorLogDAO.queryOperatorLogList(operationLogDO);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
public void batchAddOptLogAsync(final List<LogDO> optLogDOList)
throws ManagerException {
taskExecutor.execute(new Runnable() {
public void run() {
try {
operatorLogDAO.batchAddOptLogAsync(optLogDOList);
} catch (DAOException e) {
// System.out.println(e);
}
}
});
}
@Override
public void addOptLogAsync(final LogDO optLogDO) throws ManagerException {
taskExecutor.execute(new Runnable() {
public void run() {
try {
insertOperatorLog(optLogDO);
} catch (ManagerException e) {
e.printStackTrace();
}
}
});
}
@Override
public List<Integer> queryLogInfoByOrderIdListAndLogInfo(
List<Integer> orderIdList, LogDO oprationLogDO)
throws ManagerException {
try {
return operatorLogDAO.queryLogInfoByOrderIdListAndLogInfo(
orderIdList, oprationLogDO);
} catch (DAOException e) {
throw new ManagerException(e);
}
}
}
spring 配置
<bean id="operatorLogManager" class="com.xiu.order.core.orders.impl.LogManagerImpl ">
<property name="taskExecutor" ref="taskExecutor"></property>
</bean>
<bean id="taskExecutor"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="30" />
</bean>
<转>
最近,由于项目里需要用到线程池来提高处理速度,记录一下spring的taskExecutor执行器来实现线程池。
这里省略了Service接口的定义和在applicationContext.xml文件中配置相应的bean(service)。
1、处理器实现类
Java代码
1.package com.shine.job;
2.
3.import java.util.List;
4.
5.import org.apache.commons.logging.Log;
6.import org.apache.commons.logging.LogFactory;
7.import org.springframework.core.task.TaskExecutor;
8.
9.import com.shine.service.Service;
10.
11./**
12. * 处理器接口实现类
13. */
14.public class ProcessorImpl implements Processor {
15.
16. // 日志对象
17. private static Log logger = LogFactory.getLog(ProcessorImpl.class);
18.
19. // 执行器
20. private TaskExecutor taskExecutor;
21.
22. // 业务接口
23. private Service service;
24.
25. public void process() {
26. // 使用多线程处理
27. taskExecutor.execute(new Runnable(){
28. public void run() {
29. try {
30. logger.debug("[Thread "
31. + Thread.currentThread().getId()
32. + " start]");
33. // 业务处理
34. service.handle(name);
35. logger.debug("[Thread "
36. + Thread.currentThread().getId()
37. + " end]");
38. } catch (RuntimeException e) {
39. logger.error("Service handle exception",e);
40. }
41. }
42. });
43. }
44. }
45.
46. public void setService(Service service) {
47. this.service = service;
48. }
49.
50. public void setTaskExecutor(TaskExecutor taskExecutor) {
51. this.taskExecutor = taskExecutor;
52. }
53.
54.}
2、applicationContext.xml配置
Xml代码
1.<!-- 线程池(执行器) -->
2.<task:executor id="taskExecutor" pool-size="1-4" queue-capacity="128" />
3.
4.<!-- 处理接口 -->
5.<bean id="processor" class="com.shine.job.ProcessorImpl">
6. <property name="service" ref="service" />
7. <property name="taskExecutor">
8. <ref bean="taskExecutor" />
9. </property>
10.</bean>
其中:
pool-size="1-4",表示线程池活跃的线程数为1,最大线程数为4;
queue-capacity="128",表示任务队列的最大容量。
PS:关于taskExecutor还有一种配置bean来实现的,其配置的写法和参数与上面基本一致。
ThreadPoolTaskExecutor的配置在网上找了很多解释没找到,看了下ThreadPoolExecutor的配置,名字差不多,应该含义也差不多。只不过ThreadPoolTaskExecutor对
ThreadPoolExecutor做了包装。
<bean id ="taskExecutor" class ="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" >
<property name ="corePoolSize" value ="5" />
<property name ="keepAliveSeconds" value ="300" />
<property name ="maxPoolSize" value ="10" />
<property name ="queueCapacity" value ="25" />
</bean> 线程的配置文件:
corePoolSize: 线程池维护线程的最少数量
keepAliveSeconds 线程池维护线程所允许的空闲时间
maxPoolSize 线程池维护线程的最大数量
queueCapacity 线程池所使用的缓冲队列
当一个任务通过execute(Runnable)方法欲添加到线程池时:
l 如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
l 如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
l 如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
l 如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。也就是:处理任务的优先级为:核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
l 当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。
发表评论
-
Spring 线程池使用2
2013-04-25 18:41 1107<!-- 配置异步线程执行器 --> < ... -
java synchronized与lock区别 转
2013-03-20 01:59 1012java synchronized与lock区别 ... -
java并发编程实践笔记(转)
2012-11-28 01:14 900一、 保证线程安全的 ... -
并发集合类ConcurrentSkipListSet
2012-11-24 03:26 5576ConcurrentSkipListSet Concu ... -
Amdahl 定律 (阿姆达尔定律)
2012-11-24 02:14 2026有些问题使用越多的资源就能越快地解决——越多的工人参 ... -
java线程内存模型,线程、工作内存、主内存
2012-11-24 02:08 18097java线程内存模型 线程、工作内存、主内存三者之间的 ... -
线程同步与异步
2012-11-22 23:53 2436Java中的线程同步与 ... -
Java 并发核心编程(转)
2012-11-06 10:16 977Java 并发核心编程(转) Java 并发核心编程 ... -
java线程:关于Callable和Future的简单使用:有返回值的线程
2012-11-06 09:19 1922分类: java_线程2012-07-03 19 ... -
java数据结构:ConcurrentSkipListSet<E>与CopyOnWriteArraySet<E>
2012-11-06 09:20 5795分类: java_数据结构 java_线程201 ... -
java线程:信号量
2012-11-06 09:20 839Java 信号量 Semaphore 介绍 Semaphore ... -
java线程:一个死锁的小程序
2012-11-06 09:20 2678死锁是这样一种 ... -
java线程:互斥锁与读写锁
2012-11-05 17:34 6998java线程:互斥锁与读写锁 分类: ja ... -
java线程:三种方式实现生产者消费者问题_3
2012-11-05 17:34 1275java线程:三种方式 ... -
java线程:几个实用的线程工具类
2012-11-05 15:15 8322java线程:几个实用的线程工具类 分类: ... -
java线程:三种方式实现生产者消费者问题_2
2012-11-05 14:26 1084java线程:三种方式实现生产者消费者问题_2 ... -
java线程:三种方式实现生产者消费者问题_1
2012-11-05 14:22 1124java线程:三种方式实现生产者消费者问题_1 ... -
java ExecutorService 线程池Callable 和 Future接口
2012-08-29 21:10 1108javaEye转载(java多线程 Callable 的实现) ... -
线程并发
2012-03-31 15:41 10111:>内存模型 究竟什么是内存模型?内存模型描述了程序中 ... -
特殊的队列:BlockingQueue 使用(转)
2012-03-28 14:49 1023本例介绍一个特殊的队列:BlockingQueue,如果Blo ...
相关推荐
线程池例子线程池例子线程池例子线程池例子
springmvc+spring线程池处理http并发请求数据同步控制问题
ActiveMQ与Spring线程池整合的一个实例。 lib库没有上传。 对于实例的讲解,在竹子的论坛有我对这个实例的帖子(http://www.java2000.net/viewthread.jsp?tid=1167) lib中包含: apache-activemq-4.1.1.jar ...
NULL 博文链接:https://hoochiang.iteye.com/blog/2249733
数据库连接是一种关键的有限的昂贵的资源,这一点在多用户网页应用程序中体现的尤为突出。对数据库连接的管理能显著影响到整个应用的伸缩性和健壮性,影响到程序的性能指标。
Spring中的同步执行器 1. SyncTaskExecutor:同步可以用SyncTaskExecutor,但这个可以说不算一个线程池,因为还在原线程执行。这个类没有实现异步调用,只是一个同步操作。 2.也可以用ThreadPoolTaskExecutor结合...
Spring 线程池 demo
最代码,http://www.zuidaima.com/share/1724478138158080.htm 的代码及例子
主要介绍了JDK线程池和Spring线程池的使用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
NULL 博文链接:https://bijian1013.iteye.com/blog/2368708
使用spring线程池多线程并发处理大批量数据,解决IO效率问题。
Spring3.2.6定时任务+线程池,实现系统后台任务多线程处理
主要介绍了Spring Boot整合FTPClient线程池的实现示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
本篇文章主要介绍了Spring线程池ThreadPoolTaskExecutor配置详情,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
主要介绍了线程池中使用spring aop事务增强,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
今天小编就为大家分享一篇关于在spring boot中使用java线程池ExecutorService的讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
今天小编就为大家分享一篇关于Spring线程池ThreadPoolExecutor配置并且得到任务执行的结果,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
spring 简介,spring事务控制,Spring注解,spring定时调用,spring线程池,springMVC,quartz,springsecurity,的详细解析文档
Spring Boot 线程池的创建、@Async 配置步骤及注意事项
Spring原理 2 Spring ioc 原理 3 Bean生命周期 3 Java反射 4 beanfactory和applicationcontext 5 类装载器ClassLoader 6 Spring aop 原理 6 Aop代理 7 Spring 事物 10 ...Spring TaskExecutor线程池 16