1、基于springboot的项目开启自动配置

package com.plateno.booking.sync.vienna;


import javax.annotation.PostConstruct;
import javax.jms.ConnectionFactory;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jms.DefaultJmsListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ImportResource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.support.converter.MessageConverter;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;


import com.plateno.booking.sync.vienna.annotation.EnableMysql;
import com.plateno.booking.sync.vienna.annotation.EnableRedis;
import com.plateno.booking.sync.vienna.jms.messageconverter.PlatenoMessageConverter;
import com.plateno.booking.sync.vienna.util.BookingRedisHelper;
import com.plateno.booking.sync.vienna.util.SpringContextUtils;
//@EnableMysql
//@EnableRedis
//开启自动配置
@SpringBootApplication(exclude = { 
        DataSourceAutoConfiguration.class,
        RedisAutoConfiguration.class
        }, scanBasePackageClasses = {
        BookingSyncVienna.class })
public class BookingSyncVienna {
    


    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication(BookingSyncVienna.class);
        springApplication.run(args);
    }


    @Autowired
    JmsTemplate jmsTemplate;


    @Bean
    MessageConverter messageConverter() {
        return new PlatenoMessageConverter();
    }


    @Bean
    SpringContextUtils springContextUtils() {
        return new SpringContextUtils();
    }


    @PostConstruct
    public void init() {
        this.jmsTemplate.setMessageConverter(messageConverter());
    }


    /**
     * 创建默认的listerFactory 
     * see:JmsListenerAnnotationBeanPostProcessor->static final String DEFAULT_JMS_LISTENER_CONTAINER_FACTORY_BEAN_NAME = "jmsListenerContainerFactory";
     * @param connectionFactory
     * @param configurer
     * @return
     */
    @Bean(name="jmsListenerContainerFactory")
    public JmsListenerContainerFactory<?> jmsListenerContainerFactory(ConnectionFactory connectionFactory,
            DefaultJmsListenerContainerFactoryConfigurer configurer) {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setMessageConverter(messageConverter());
        configurer.configure(factory, connectionFactory);
        return factory;
    }


/*  @Bean
    @Autowired
    public BookingRedisHelper redisHelper(RedisTemplate redisTemplate) {
        BookingRedisHelper bookingRedisHelper = new BookingRedisHelper();
        bookingRedisHelper.setRedisTemplate(redisTemplate);
        return bookingRedisHelper;
    }
*/
    /*
     * @Bean public DefaultJmsListenerContainerFactory
     * listenerContainerFactory() { DefaultJmsListenerContainerFactory factory =
     * new DefaultJmsListenerContainerFactory();
     * factory.setConnectionFactory(connectionFactory());
     * factory.setMessageConverter(objectConverter());
     * factory.setConcurrency("5"); return factory; }
     */
    /*
     * @Bean public ConnectionFactory connectionFactory(){
     * PooledConnectionFactory pooledConnectionFactory = new
     * PooledConnectionFactory(); ActiveMQConnectionFactory mqConnectionFactory
     * = new ActiveMQConnectionFactory();
     * mqConnectionFactory.setBrokerURL(brokerUrl);
     * mqConnectionFactory.setUseAsyncSend(true);
     * mqConnectionFactory.setOptimizeAcknowledgeTimeOut(3000);
     * pooledConnectionFactory.setConnectionFactory(mqConnectionFactory);
     * pooledConnectionFactory.setMaxConnections(20);
     * mqConnectionFactory.setTransactedIndividualAck(true); return
     * pooledConnectionFactory; }
     */
}

2、创建作业类

package com.plateno.booking.sync.vienna.test;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.plateno.booking.sync.vienna.properties.CronProperties;

@Component
@ConditionalOnProperty(prefix = "", name = "test", havingValue = "true")
public class TestJob {
    
    private static Logger logger = LoggerFactory.getLogger(TestJob.class);
    
    @Scheduled(cron="0/2 * * * * ?")
    @Async//异步执行，配合线程池实现并发
    public void test(){
        
        System.err.println("---------------------");
        System.err.println("a");
        logger.error(Thread.currentThread().getName());
        System.err.println("---------------------");
        try {
            Thread.sleep(20000);//执行睡眠，这样如果并发执行，那么上面的打印会2秒执行一次，而下面的ffff则会22秒打印一次
            System.out.println("ffff");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    
    /*@Scheduled(cron="0/1 * * * * ?")
    public void test1(){
        System.err.println("---------------------");
        System.err.println("b");
        logger.error(Thread.currentThread().getName());
        System.err.println("---------------------");
    }*/
}

3、定义线程池配置文件（@enableSchedulling@scheduled默认是基于单线程），多线程并发需要配置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/beans
            http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.2.xsd
            http://www.springframework.org/schema/task
            http://www.springframework.org/schema/task/spring-task-4.2.xsd">

 <task:scheduler id="scheduler" pool-size="10" />
<task:executor id="executor" keep-alive="7200" pool-size="100-200"
queue-capacity="500" rejection-policy="CALLER_RUNS" />
<task:annotation-driven executor="executor"
scheduler="scheduler" />
</beans>

同时，如果想使用注解开发

配置类加上@EnableAsync即可，本质上都是创建AsyncAnnotationBeanPostProcessor对象，另外如果要自定义excutor和exceptionHandller，可以参考@EnableAsync源码
注释：

/**
 * Enables Spring's asynchronous method execution capability, similar to functionality
 * found in Spring's {@code <task:*>} XML namespace.
 *
 * <p>To be used on @{@link Configuration} classes as follows, where {@code MyAsyncBean}
 * is a user-defined type with one or more methods annotated with either Spring's
 * {@code @Async} annotation, the EJB 3.1 {@code @javax.ejb.Asynchronous} annotation,
 * or any custom annotation specified via the {@link #annotation} attribute.
 *
 * <pre class="code">
 * @Configuration
 * @EnableAsync
 * public class AppConfig {
 *
 *     @Bean
 *     public MyAsyncBean asyncBean() {
 *         return new MyAsyncBean();
 *     }
 * }</pre>
 *
 * <p>The {@link #mode} attribute controls how advice is applied; if the mode is
 * {@link AdviceMode#PROXY} (the default), then the other attributes control the behavior
 * of the proxying.
 *
 * <p>Note that if the {@linkplain #mode} is set to {@link AdviceMode#ASPECTJ}, then the
 * value of the {@link #proxyTargetClass} attribute will be ignored. Note also that in
 * this case the {@code spring-aspects} module JAR must be present on the classpath.
 *
 * <p>By default, Spring will be searching for an associated thread pool definition:
 * either a unique {@link org.springframework.core.task.TaskExecutor} bean in the context,
 * or an {@link java.util.concurrent.Executor} bean named "taskExecutor" otherwise. If
 * neither of the two is resolvable, a {@link org.springframework.core.task.SimpleAsyncTaskExecutor}
 * will be used to process async method invocations. Besides, annotated methods having a
 * {@code void} return type cannot transmit any exception back to the caller. By default,
 * such uncaught exceptions are only logged.
 *
 * <p>To customize all this, implement {@link AsyncConfigurer} and provide:
 * <ul>
 * <li>your own {@link java.util.concurrent.Executor Executor} through the
 * {@link AsyncConfigurer#getAsyncExecutor getAsyncExecutor()} method, and</li>
 * <li>your own {@link org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler
 * AsyncUncaughtExceptionHandler} through the {@link AsyncConfigurer#getAsyncUncaughtExceptionHandler
 * getAsyncUncaughtExceptionHandler()}
 * method.</li>
 * </ul>
 *
 * <pre class="code">
 * @Configuration
 * @EnableAsync
 * public class AppConfig implements AsyncConfigurer {
 *
 *     @Bean
 *     public MyAsyncBean asyncBean() {
 *         return new MyAsyncBean();
 *     }
 *
 *     @Override
 *     public Executor getAsyncExecutor() {
 *         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 *         executor.setCorePoolSize(7);
 *         executor.setMaxPoolSize(42);
 *         executor.setQueueCapacity(11);
 *         executor.setThreadNamePrefix("MyExecutor-");
 *         executor.initialize();
 *         return executor;
 *     }
 *
 *     @Override
 *     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
 *         return MyAsyncUncaughtExceptionHandler();
 *     }
 * }</pre>
 *
 * <p>If only one item needs to be customized, {@code null} can be returned to
 * keep the default settings. Consider also extending from {@link AsyncConfigurerSupport}
 * when possible.
 *
 * <p>Note: In the above example the {@code ThreadPoolTaskExecutor} is not a fully managed
 * Spring bean. Add the {@code @Bean} annotation to the {@code getAsyncExecutor()} method
 * if you want a fully managed bean. In such circumstances it is no longer necessary to
 * manually call the {@code executor.initialize()} method as this will be invoked
 * automatically when the bean is initialized.
 *
 * <p>For reference, the example above can be compared to the following Spring XML
 * configuration:
 *
 * <pre class="code">
 * {@code
 * <beans>
 *
 *     <task:annotation-driven executor="myExecutor" exception-handler="exceptionHandler"/>
 *
 *     <task:executor id="myExecutor" pool-size="7-42" queue-capacity="11"/>
 *
 *     <bean id="asyncBean" class="com.foo.MyAsyncBean"/>
 *
 *     <bean id="exceptionHandler" class="com.foo.MyAsyncUncaughtExceptionHandler"/>
 *
 * </beans>
 * }</pre>

参考：http://docs.spring.io/spring/docs/current/spring-framework-reference/html/scheduling.html

执行结果：
睡眠之前的2秒打印一次，睡眠之后的22秒打印一次