赖赖的博客

06 Spring 异步执行,任务调度(@Schedule、@Async)

转载请注明来源 赖赖的博客

导语

一个简单的抽象,可以解决百分之八十的问题。

在写Spring 应用的时候,会遇到一些异步执行和任务调度的问题,例如:Spring MVC中需要向微信发送请求,告诉微信进行公众号推送。这个时候需要用到异步执行,而周报表、月报表、日最高点击等,需要用到任务调度。
Spring高度凝聚了及其简单的调度和异步执行方式,迅速解决百分之八十的问题。

实例

项目工程目录结构和代码获取地址

获取地址(版本Log将会注明每一个版本对应的课程)

https://github.com/laiyijie/SpringLearning

目录结构

目录结构

运行工程

运行具有Main函数的 App.java
得到如下输出

the 2 time to say userHello
the 0 time to say userHello
the 3 time to say userHello
the 1 time to say userHello
the 4 time to say userHello
the 6 time to say userHello
the 5 time to say userHello
the 8 time to say userHello
the 9 time to say userHello
the 7 time to say userHello
time:1480341514063 userHello
time:1480341515064 userHello
time:1480341516065 userHello
time:1480341517066 userHello
time:1480341518067 userHello
time:1480341519068 userHello
time:1480341520069 userHello
time:1480341521070 userHello
time:1480341522071 userHello

项目详解

从App.java入手

App.java

package me.laiyijie.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import me.laiyijie.demo.service.HelloInterface;

public class App {
    public static void main(String[] args) throws InterruptedException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("root-context.xml");

        HelloInterface hello = context.getBean(HelloInterface.class);

        for (int i = 0; i < 10; i++) {
            hello.sayHello(i);
        }

        Thread.sleep(10000);

        context.close();
    }
}

主函数中有一个for循环,调用的是HelloInterfacesayHello方法。
并且主线程休眠了10秒后关闭ApplicationContext

HelloInterface.java

package me.laiyijie.demo.service;

public interface HelloInterface{

    void sayHello(int i );
    void sayHelloEverySecondes();
}

接口,并定义了两个函数,其实现类为 UserServiceImpl

UserServiceImpl.java

package me.laiyijie.demo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements HelloInterface {

    @Async
    public void sayHello(int i) {

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("the " + i + " time to say " + "userHello");
    }

    @Scheduled(fixedDelay = 1000)
    public void sayHelloEverySecondes() {

        System.out.println("time:" + System.currentTimeMillis() + " userHello");
    }

}  

实现了两个函数,而且两个函数前面分别有@Async@Scheduled两个注解。
分别探讨:

@Async 异步执行

@Async标注过的方法不是在主线程中执行,是另开了一个线程,并且进行调度,从打印就可以看出,调度是随机的!

既然涉及到异步,就涉及到线程池有多大?队列有多大?
root-context.xml中有如下配置:

<task:executor id="myExecutor" pool-size="5" queue-capacity="100"/>  

pool-size=5 : 线程池的大小为5!
queue-capacity=100 : 等待队列的最大长度为100!

所以可以看到,前面的输出,0-4次userHello在5-9次前面,因为一次只能同时执行五个线程。

@Scheduled(fixedDelay = 1000)

@Scheduled标注过的函数会按照配置的运行方式自动执行!此处配置的是fixedDelay=1000含义是每隔1000ms执行一次(在上次执行完后开始计时1000ms)
定时调度一样有一个线程池:

<task:scheduler id="myScheduler" pool-size="5"/>  

含义与executor一致

需要开启@Async@Scheduled,root-context.xml需要进行如下配置:

root-context.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"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.3.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <context:component-scan base-package="me.laiyijie.demo"></context:component-scan>

    <task:annotation-driven executor="myExecutor" scheduler="myScheduler" />
    <task:scheduler id="myScheduler" pool-size="5"/>
    <task:executor id="myExecutor" pool-size="5" queue-capacity="100"/>

</beans>

变更如下:

  • 增加task命名空间

    xmlns:task="http://www.springframework.org/schema/task"
    
  • 增加注解驱动以及执行器

    <task:annotation-driven executor="myExecutor" scheduler="myScheduler" />
    <task:scheduler id="myScheduler" pool-size="5"/>
    <task:executor id="myExecutor" pool-size="5" queue-capacity="100"/>
    

虽然可以最简单的使用:

<task:annotation-driven />   

但是建议还是自己定义executorscheduler方便控制资源大小

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>me.laiyijie</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.2.RELEASE</version>
        </dependency>

    </dependencies>
</project>  

小结

  1. 异步执行使用 @Async标注方法
  2. 定时任务使用@Scheduled 标注方法