spring 集成线程池(TaskExecutor)

野性酷女 2023-10-16 23:27 10阅读 0赞

本文转载至：[http://rainyear.iteye.com/blog/1466140][http_rainyear.iteye.com_blog_1466140]

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，线程将被终止。这样，线程池可以动态的调整池中的线程数。

[http_rainyear.iteye.com_blog_1466140]: http://rainyear.iteye.com/blog/1466140