spring task定时任务实现

1. task与Quartz区别

    Spring从3.0开始增加了自己的任务调度器，它是通过扩展java.util.concurrent包下面的类来实现的，它也使用Cron表达式。
    对于Quartz，我们使用的时候主要是注重两个方面，一个是定时任务的业务，另一个就是Cron表达式。定时任务跟具体的业务相关，这无需多说，这里只说明表达式含义及其写法。
    简单的来说task是Quartz的轻量级封装。task不需要而外引入jar包，完全依赖与spring 相关jar.

2. task有两种配置方式，一种是依赖配置文件，第二种是注解实现；

 1.第一种方式大家可以参考一下其他的，主要讲解第二种配置方式，因为比较简介，迅速；
 2.第二种方式：可以直接在spring配置文件中增加命名空间task ;
 `<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans    
                    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd    
                    http://www.springframework.org/schema/context    
                    http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                    http://www.springframework.org/schema/mvc    
                    http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                    http://www.springframework.org/schema/tx 
                    http://www.springframework.org/schema/tx/spring-tx-3.2.xsd 
                    http://www.springframework.org/schema/aop 
                    http://www.springframework.org/schema/aop/spring-aop.xsd
                    http://www.springframework.org/schema/task 
                    http://www.springframework.org/schema/task/spring-task.xsd">`

3. 第二步 ：

`   <!-- 自动扫描的包名 -->
    <context:component-scan base-package="com.meyacom" />
    <!-- 如果定时任务很多，可以配置executor线程池，这里executor的含义和java.util.concurrent.Executor是一样的，pool-size的大小官方推荐为5~10。scheduler的pool-size是ScheduledExecutorService线程池， -->
<!--    <task:executor id="executor" pool-size="10" /> -->
    <!-- 定时任务前缀 -->
<!--    <task:scheduler id="scheduler" pool-size="10" /> -->
    <!-- 定时器开关 -->
    <task:annotation-driven  executor="executor"
        scheduler="scheduler"/>`


        <!--或者使用一下代码 配置线程池-->
            <!-- 自动扫描的包名 -->
    <context:component-scan base-package="com.meyacom" />
    <!-- 如果定时任务很多，可以配置executor线程池，这里executor的含义和
    <!-- 定时任务前缀 -->
    <task:scheduler id="scheduler" pool-size="${task.core_pool_size}" />
    <!-- 定时器开关 -->
    <task:annotation-driven executor="taskExecutor"
        scheduler="scheduler" />

    <!-- task 引入配置文件 -->
    <!-- 配置在jdbc.properties文件中 -->

    <!-- 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。 如果此时线程池中的数量等于 
        corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。 
        如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 
        handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。 
        当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。 -->
    <!-- 线程池 -->
    <bean id="taskExecutor"
    class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <!-- 核心线程数 -->

    <property name="corePoolSize" value="${task.core_pool_size}" />
    <!-- 最大线程数 -->

    <property name="maxPoolSize" value="${task.max_pool_size}" />
    <!-- 队列最大长度 线程池所使用的缓冲队列 -->

    <property name="queueCapacity" value="${task.queue_capacity}" />
    <!-- 线程池维护线程所允许的空闲时间，默认为60s -->

     <property name="keepAliveSeconds" value="${task.keep_alive_seconds}" 
        /> 
    </bean>

第3步：task 数据，配置在jdbc.properties中

#------------ Task ------------
task.core_pool_size=10
task.max_pool_size=50
task.queue_capacity=1000
task.keep_alive_seconds=60

第四步 ：编写测试方法

@Service
@Component
public class TaskServiceImpl implements TaskService{

    @Scheduled(cron="0/5 * *  * * ? ")   //每5秒执行一次  
    @Override
    public void myTest() {
        // TODO Auto-generated method stub      
        System.out.println(Thread.currentThread().getThreadGroup()+" "+Thread.currentThread().getName()+" "+"定时任务一：mytest1--------------------------开始");
    }

    @Scheduled(cron="0/5 * *  * * ? ")   //每5秒执行一次  
    @Override
    public void myTest2() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+" "+"定时任务二：mytest2--------------------------开始");
    }

    @Scheduled(cron="0/5 * *  * * ? ")   //每5秒执行一次  
    @Override
    public void myTest3() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+" "+"定时任务三：mytest3--------------------------开始");
    }

}

第五步：测试结果 ##

java.lang.ThreadGroup[name=main,maxpri=10] scheduler-3 定时任务一：mytest1--------------------------开始
scheduler-1 定时任务二：mytest2--------------------------开始
java.lang.ThreadGroup[name=main,maxpri=10] scheduler-6 定时任务一：mytest1--------------------------开始
scheduler-4 定时任务三：mytest3--------------------------开始
java.lang.ThreadGroup[name=main,maxpri=10] scheduler-4 定时任务一：mytest1--------------------------开始
scheduler-3 定时任务三：mytest3--------------------------开始
scheduler-2 定时任务二：mytest2--------------------------开始
scheduler-10 定时任务二：mytest2--------------------------开始
java.lang.ThreadGroup[name=main,maxpri=10] scheduler-6 定时任务一：mytest1--------------------------开始
scheduler-9 定时任务三：mytest3--------------------------开始