spring-线程池(1)

spring-线程池(1)

多线程并发处理起来通常比较麻烦,如果你使用spring容器来管理业务bean,事情就好办了多了。spring封装了java的多线程的实现,你只需要关注于并发事物的流程以及一些并发负载量等特性,具体来说如何使用spring来处理并发事务:

1.了解 TaskExecutor接口

Spring的 TaskExecutor接口等同于java.util.concurrent.Executor接口 实际上,它存在的主要原因是为了在使用线程池的时候,将对Java 5的依赖抽象出来。 这个接口只有一个方法execute(Runnable task),它根据线程池的语义和配置,来接受一个执行任务。最初创建TaskExecutor是为了在需要时给其他Spring组件提供一个线程池的抽 象。 例如ApplicationEventMulticaster组件、JMS的 AbstractMessageListenerContainer和对Quartz的整合都使用了TaskExecutor抽象来提供线程池。 当然,如果你的bean需要线程池行为,你也可以使用这个抽象层。

2. TaskExecutor接口的实现类

(1)SimpleAsyncTaskExecutor 类

这个实现不重用任何线程,或者说它每次调用都启动一个新线程。但是,它还是支持对并发总数设限,当超过线程并发总数限制时,阻塞新的调用,直到有位置被释放。如果你需要真正的池,请继续往下看。

(2)SyncTaskExecutor类

这个实现不会异步执行。相反,每次调用都在发起调用的线程中执行。它的主要用处是在不需要多线程的时候,比如简单的test case。

(3)ConcurrentTaskExecutor 类

这个实现是对 Java 5 java.util.concurrent.Executor类的包装。有另一个备选, ThreadPoolTaskExecutor类,它暴露了Executor的配置参数作为bean属性。很少需要使用 ConcurrentTaskExecutor, 但是如果ThreadPoolTaskExecutor不敷所需,ConcurrentTaskExecutor是另外一个备选。

(4)SimpleThreadPoolTaskExecutor 类

这个实现实际上是Quartz的SimpleThreadPool类的子类,它会监听Spring的生命周期回调。当你有线程池,需要在Quartz和非Quartz组件中共用时,这是它的典型用处。

(5)ThreadPoolTaskExecutor 类

它不支持任何对 java.util.concurrent包的替换或者下行移植。Doug Lea和Dawid Kurzyniec对java.util.concurrent的实现都采用了不同的包结构,导致它们无法正确运行。 这个实现只能在Java 5环境中使用,但是却是这个环境中最常用的。它暴露的bean properties可以用来配置一个java.util.concurrent.ThreadPoolExecutor,把它包装到一个 TaskExecutor中。如果你需要更加先进的类,比如ScheduledThreadPoolExecutor,我们建议你使用 ConcurrentTaskExecutor来替代。

(6)TimerTaskExecutor类

这个实现使用一个TimerTask作为其背后的实现。它和SyncTaskExecutor的不同在于,方法调用是在一个独立的线程中进行的,虽然在那个线程中是同步的。

(7)WorkManagerTaskExecutor类

这个实现使用了 CommonJ WorkManager作为其底层实现,是在Spring context中配置CommonJ WorkManager应用的最重要的类。和SimpleThreadPoolTaskExecutor类似,这个类实现了WorkManager接口, 因此可以直接作为WorkManager使用。 

 

3. 简单hellword

 

3.1 线程类


public class MessagePrinterTask implements Runnable {
    private String message;

    public MessagePrinterTask() {

    }
    public MessagePrinterTask(String message) {
        this.message = message;
    }

    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(message);
    }
}

 

3.1 线程管理工具类


import org.springframework.core.task.TaskExecutor;

public class TaskExecutorUtil {
    
    private TaskExecutor taskExecutor;
    public TaskExecutor getTaskExecutor() {
        return taskExecutor;
    }

    public void setTaskExecutor(TaskExecutor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    public void printMessages(Runnable r,int i) {
            taskExecutor.execute(r);
            System.out.println("add Thread:"+i);
    }


}

 

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans  
xmlns="http://www.springframework.org/schema/beans"  
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xmlns:context="http://www.springframework.org/schema/context"  
xsi:schemaLocation="  
http://www.springframework.org/schema/beans        
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
http://www.springframework.org/schema/context                
http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
  <!-- 异步线程池 --> 
<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> 
    <!-- 核心线程数  -->  
    <property name="corePoolSize" value="2" />  
    <!-- 最大线程数 -->  
    <property name="maxPoolSize" value="3" />  
    <!-- 队列最大长度 >=mainExecutor.maxSize -->  
    <property name="queueCapacity" value="10" />  
    <!-- 线程池维护线程所允许的空闲时间 -->  
    <property name="keepAliveSeconds" value="300" />  
    <!-- 线程池对拒绝任务(无线程可用)的处理
    策略 --> <!-- 若不作该处理,当线程满了,队列满了之后,继续往下增加任务,则抛出异常,拒绝该任务 --> 
    <property name="rejectedExecutionHandler">  
      <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />  
    </property>
</bean>
  
<bean id="taskExecutorUtil" class="TaskExecutorUtil">    
    <!-- <constructor-arg ref="taskExecutor" />  --> 
    <property name="taskExecutor" ref="taskExecutor" /> 
</bean> 

<!-- 托管线程 -->
<bean id="messagePrinterTask" class="MessagePrinterTask">    
</bean> 

  
  
</beans>


 

测试

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");    
        TaskExecutorUtil te = (TaskExecutorUtil)appContext.getBean("taskExecutorUtil");   
        
        for (int i = 0; i < 25; i++) {
            MessagePrinterTask m=new MessagePrinterTask("Message" + i);
            te.printMessages(m,i); 
        } 
        System.out.println("11111111111111111111111"); 
    }
}
复制代码
结果输出
复制代码
add Thread:0
add Thread:1
add Thread:2
add Thread:3
add Thread:4
add Thread:5
add Thread:6
add Thread:7
add Thread:8
add Thread:9
add Thread:10
add Thread:11
add Thread:12
Message1
Message0
Message13
add Thread:13
Message12
add Thread:14
add Thread:15
add Thread:16
Message2
Message4
Message17
add Thread:17
Message3
add Thread:18
add Thread:19
add Thread:20
Message5
Message7
Message21
add Thread:21
Message6
add Thread:22
add Thread:23
add Thread:24
11111111111111111111111
Message9
Message8
Message10
Message14
Message15
Message11
Message18
Message19
Message16
Message22
Message23
Message20
Message24

 

解释:

1.因为线程类睡眠5秒,所以在5秒前add Thread增加了13个线程(3个最大线程+10个在队列中等候),由于在做了对了满了的策略(rejectedExecutionHandler),所以不会抛出异常,

其他线程等候加入队列

2.五秒后打印,然后继续addThread,打印message,注意当前最大线程执行是3个,,其余在队列等候,然后打印剩余线程,111111111111是主线程

 

 

4、配置解释
当一个任务通过execute(Runnable)方法欲添加到线程池时:
1、 如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
2、 如果此时线程池中的数量等于 corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。
3、如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
4、 如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。也就是:处理任务的优先级为:核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。
5、 当线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。

 

 

 

 

5. 线程类为 java.util.concurrent.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()
抛弃当前的任务


 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值