java使用quartz or 线程池实现定时任务功能

首先说下思路

定时任务→避免重复提交数据

先从数据库里查询dateTime（日期或者时间），通过查询到的dateTime日期时间和系统时间（new Date（））做比较

如果库里的日期小于现在的系统日期则同步数据，否则不同步。当开启这个业务时则每天自动同步一次数据。

这里涉及到俩点

1.比较时间   before方法-- Date类的一个方法，如果a早于b返回true，否则返回false

2.每天自动同步数据--可以使用线程池后面会说到

1.比较时间eg:

Date date=new Date();    
		 System.out.println(date);
		 SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 
		 String beginDate=sdf.format(date);
		 String newDate="2018-03-21";
		 String endDate="2018-03-19";
		  Date bt1=sdf.parse(beginDate); 
		  Date bt=sdf.parse(newDate); 
		  Date et=sdf.parse(endDate); 
		  if(et.before(bt)) {
			  System.out.println("1");
		  }else {
			  System.out.println("2");
		  }

2.每天自动同步数据

一.普通Thread 

eg:

/**  
 * 普通thread  
 * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，  
 * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：  
 * @author YGC  
 *  
 */    
public class Task1 {    
    public static void main(String[] args) {    
        // run in a second    
        final long timeInterval = 1000;    
        Runnable runnable = new Runnable() {    
            public void run() {    
                while (true) {    
                    // ------- code for task to run    
                    System.out.println("Hello !!");    
                    // ------- ends here    
                    try {    
                        Thread.sleep(timeInterval);    
                    } catch (InterruptedException e) {    
                        e.printStackTrace();    
                    }    
                }    
            }    
        };    
        Thread thread = new Thread(runnable);    
        thread.start();    
    }    
}

二.线程池

eg:Java可以用java.util.concurrent.ScheduledExecutorService 来实现定时任务

import java.util.concurrent.Executors;    
import java.util.concurrent.ScheduledExecutorService;    
import java.util.concurrent.TimeUnit;    
    
/**  
 *   
 *   
 * ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。   
 * 相比于上两个方法，它有以下好处：  
 * 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的   
 * 2>可以很灵活的去设定第一次执行任务delay时间  
 * 3>提供了良好的约定，以便设定执行的时间间隔  
 *   
 * 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。  
 *   
 *   
 * @author YGC  
 *   
 */    
public class Task3 {    
    public static void main(String[] args) {    
        Runnable runnable = new Runnable() {    
            public void run() {    
                // task to run goes here    
                System.out.println("Hello !!");    
            }    
        };    
        ScheduledExecutorService service = Executors    
                .newSingleThreadScheduledExecutor();    
        // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间    
        service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);    
    }    
}

第三种spring quartz来做定时任务

eg: ApplicationContext.xml 配置

<!-- 定时任务 -->
<bean id="EventNotificationTimedTaskDao" class="cn.secure.dao.EventNotificationTimedTaskDao">
		<property name="jdbcTemplate" ref="jdbcTemplate" />
	</bean>
	<bean id="EventNotificationTimedTaskService" class="cn.secure.service.impl.EventNotificationTimedTaskServiceImpl">
		<property name="EventNotificationTimedTaskDao" ref="EventNotificationTimedTaskDao" />
	</bean>
	
	<bean id="myTask" class="cn.secure.web.front.EventNotificationTimedTaskController">
		<property name="EventNotificationTimedTaskService" ref="EventNotificationTimedTaskService" />
	</bean>
			
	<bean id="upgradeJobDetail1" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">	
		     <property name="targetObject">
                <ref bean="myTask"/>
            </property>
            <!-- 调用类中的方法 -->
            <property name="targetMethod">
                <value>addHttpNowData</value>
            </property>
		<property name="concurrent" value="false" />

	</bean>
	<bean id="doTime" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		 	<property name="jobDetail">
                <ref bean="upgradeJobDetail1"/>
            </property>
            <!-- cron表达式 -->
            <property name="cronExpression">
                <value>0/2 * * ? * *</value>
            </property>
	</bean>				

		<!-- 线程执行器配置，用于任务注册 -->
	<bean id="executor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
		<property name="corePoolSize" value="50" />
		<property name="maxPoolSize" value="100" />
		<property name="queueCapacity" value="500" />

	</bean>
	
    <!-- 设置调度 开启定时任务 -->
	<bean id="startQuertz"   lazy-init="false"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">	 

		<property name="triggers">
			<list>	
			     <ref bean="doTime"  />		
			</list>
		</property>
		
		<property name="taskExecutor" ref="executor" />
	<property name="autoStartup" value="true" />
	</bean>

TimedTaskController ↓

public EventNotificationTimedTaskService getEventNotificationTimedTaskService() {
		return eventNotificationTimedTaskService;
	}
	public void setEventNotificationTimedTaskService(EventNotificationTimedTaskService eventNotificationTimedTaskService) {
		this.eventNotificationTimedTaskService = eventNotificationTimedTaskService;
	}
	
	public void addHttpNowData()  { 
			// 从接口获取数据
		try {
			this.eventNotificationTimedTaskService.addHttpNoticeData();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	 }