java定时任务spring_java：spring的定时任务是无限队列吗并发的情况下会不会发生oom

❶ java：spring的定时任务是无限队列吗，并发的情况下会不会发生oom

肯定会啊，定时任务也是线程池，池子满了就好挤出去

❷ 如何在spring中配置定时任务

spring的定时任务配置分为三个步骤：
1、定义任务
2、任务执行策略配置
3、启动任务

1、定义任务

<bean id="testTaskJob"
class="org.springframework.scheling.quartz.">
<property name="targetObject">

<ref bean="testTask" />
</property>
<property name="targetMethod">

<value>execute</value>
</property>
<property name="concurrent">

<value>false</value>
</property>
</bean>

2、任务执行策略配置
(1)指定重复间隔的定时任务

<bean id="testTaskJobTrigger"
class="org.springframework.scheling.quartz.SimpleTriggerBean">
<property name="jobDetail">
<ref bean="testTaskJob" />
</property>

<property name="startDelay" value="60000"></property>

<property name="repeatInterval" value="60000">
</property>
</bean>

(2)按周期执行的任务

<bean id="doTime"
class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="testTaskJob" />
</property>

<property name="cronExpression">
<value>0 42 10 * * ?</value>
</property>
</bean>

3、启动任务

<bean lazy-init="false"
class="org.springframework.scheling.quartz.SchelerFactoryBean">
<property name="triggers">
<list>

<ref local="testTaskJobTrigger" />
</list>
</property>
</bean>

至此，系统启动的时候，就能加载定时任务，并按照指定的定时策略执行。

对于一次性定时任务，一般有如下几种形式：(1)使用spring的init方法；(2)在使用时判断是否需要加载，确保只执行一次。

cron表达式的基本使用：

字段允许值允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选）留空, 1970-2099 , - * /
表达式意义
"0 0 12 * * ?" 每天中午12点触发
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
"0 15 10 15 * ?" 每月15日上午10:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发
每天早上6点
0 6 * * *
每两个小时
0 */2 * * *
晚上11点到早上8点之间每两个小时，早上八点
0 23-7/2，8 * * *
每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点
0 11 4 * 1-3
1月1日早上4点
0 4 1 1 *

❸ spring boot的定时任务应该如何使用

1) Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。最早的时候就是这样写定时任务的。
2) 开源的第三方框架： Quartz 或者 elastic-job ，但是这个比较复杂和重量级，适用于分布式场景下的定时任务，可以根据需要多实例部署定时任务。
3) 使用Spring提供的注解： @Schele 。如果定时任务执行时间较短，并且比较单一，可以使用这个注解。
案例：
@SpringBootApplication
/*
* 开启对定时任务的支持
* 在相应的方法上添加@Scheled声明需要执行的定时任务。
*/
@EnableScheling
//@EnableScheling注解来开启对计划任务的支持
public class Application {

public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

@Component
public class ScheledTasks {

private Logger logger = LoggerFactory.getLogger(ScheledTasks.class);

private int i=0;
//0 0 0 2 * ?
@Scheled(cron="* * * 2 * ?")
//@Scheled 注解用于标注这个方法是一个定时任务的方法
public void testFixDelay() {
logger.info("执行方法"+i++);
}

❹ Spring定时任务为什么没有执行

Spring定时任务的几种实现

博客分类：
spring框架
quartzspringspring-task定时任务注解
Spring定时任务的几种实现

近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合
spring框架来介绍。
一．分类

从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：

Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。
使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。
从作业类的继承方式来讲，可以分为两类：

作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。
作业类即普通的java类，不需要继承自任何基类。
注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。

从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：

每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheling.quartz.SimpleTriggerBean
每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheling.quartz.CronTriggerBean
注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。

二．用法说明

详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。
Quartz

第一种，作业类继承自特定的基类：org.springframework.scheling.quartz.QuartzJobBean。

第一步：定义作业类

Java代码
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheling.quartz.QuartzJobBean;
public class Job1 extends QuartzJobBean {

private int timeout;
private static int i = 0;
//调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout = timeout;
}

/**
* 要调度的具体任务
*/
@Override
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
System.out.println("定时任务执行中…");
}
}
第二步：spring配置文件中配置作业类JobDetailBean
Xml代码
<bean name="job1" class="org.springframework.scheling.quartz.JobDetailBean">
<property name="jobClass" value="com.gy.Job1" />
<property name="jobDataAsMap">
<map>
<entry key="timeout" value="0" />
</map>
</property>
</bean>
说明：org.springframework.scheling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheling.quartz.SimpleTriggerBean
org.springframework.scheling.quartz.CronTriggerBean
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
配置方式如下：

Xml代码
<bean id="simpleTrigger" class="org.springframework.scheling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="job1" />
<property name="startDelay" value="0" />
<property name="repeatInterval" value="2000" />
</bean>
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
配置方式如下：
Xml代码
<bean id="cronTrigger" class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail" ref="job1" />
<!—每天12:00运行一次 -->
<property name="cronExpression" value="0 0 12 * * ?" />
</bean>
关于cronExpression表达式的语法参见附录。
第四步：配置调度工厂
Xml代码
<bean class="org.springframework.scheling.quartz.SchelerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>
说明：该参数指定的就是之前配置的触发器的名字。
第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

第二种，作业类不继承特定基类。

Spring能够支持这种方式，归功于两个类：
org.springframework.scheling.timer.
org.springframework.scheling.quartz.
这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。
第一步：编写任务类
Java代码
public class Job2 {
public void doJob2() {
System.out.println("不继承QuartzJobBean方式-调度进行中...");
}
}
可以看出，这就是一个普通的类，并且有一个方法。
第二步：配置作业类
Xml代码
<bean id="job2"
class="org.springframework.scheling.quartz.">
<property name="targetObject">
<bean class="com.gy.Job2" />
</property>
<property name="targetMethod" value="doJob2" />
<property name="concurrent" value="false" />
</bean>
说明：这一步是关键步骤，声明一个，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheling.quartz.SimpleTriggerBean
org.springframework.scheling.quartz.CronTriggerBean
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
配置方式如下：
Xml代码
<bean id="simpleTrigger" class="org.springframework.scheling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="job2" />
<property name="startDelay" value="0" />
<property name="repeatInterval" value="2000" />
</bean>
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
配置方式如下：
Xml代码
<bean id="cronTrigger" class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail" ref="job2" />
<!—每天12:00运行一次 -->
<property name="cronExpression" value="0 0 12 * * ?" />
</bean>
以上两种调度方式根据实际情况，任选一种即可。
第四步：配置调度工厂
Xml代码
<bean class="org.springframework.scheling.quartz.SchelerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>
说明：该参数指定的就是之前配置的触发器的名字。
第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。
其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！
请看我第下文Spring task的介绍。

Spring-Task

上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种
形式，下面将分别介绍这两种方式。
第一种：配置文件方式

第一步：编写作业类
即普通的pojo，如下：
Java代码
import org.springframework.stereotype.Service;
@Service
public class TaskJob {

public void job1() {
System.out.println(“任务进行中。。。”);
}
}
第二步：在spring配置文件头中添加命名空间及描述
Xml代码
<beans xmlns="/schema/beans"
xmlns:task="/schema/task"
。。。。。。
xsi:schemaLocation="/schema/task h
k.org/schema/task/spring-task-3.0.xsd">
第三步：spring配置文件中设置具体的任务
Xml代码
<task:scheled-tasks>
<task:scheled ref="taskJob" method="job1" cron="0 * * * * ?"/>
</task:scheled-tasks>

<context:component-scan base-package=" com.gy.mytask " />
说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。
<context:component-scan base-package="com.gy.mytask" />这个配置不消多说了，spring扫描注解用的。
到这里配置就完成了，是不是很简单。
第二种：使用注解形式

也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheled，我们看看源文件中该注解的定义：
Java代码
@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scheled
{
public abstract String cron();

public abstract long fixedDelay();

public abstract long fixedRate();
}
可以看出该注解有三个方法或者叫参数，分别表示的意思是：
cron：指定cron表达式
fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。
fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。

下面我来配置一下。
第一步：编写pojo
Java代码
import org.springframework.scheling.annotation.Scheled;
import org.springframework.stereotype.Component;

@Component(“taskJob”)
public class TaskJob {
@Scheled(cron = "0 0 3 * * ?")
public void job1() {
System.out.println(“任务进行中。。。”);
}
}
第二步：添加task相关的配置：
Xml代码

<context:annotation-config />
<!—spring扫描注解的配置 -->
<context:component-scan base-package="com.gy.mytask" />

<!—开启这个配置，spring才能识别@Scheled注解 -->
<task:annotation-driven scheler="qbScheler" mode="proxy"/>
<task:scheler id="qbScheler" pool-size="10"/>
说明：理论上只需要加上<task:annotation-driven />这句配置就可以了，这些参数都不是必须的。

Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档schema/task/spring-task-3.0.xsd。
附录：
cronExpression的配置说明，具体使用以及参数请网络google
字段允许值允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选）留空, 1970-2099 , - * /
- 区间
* 通配符
? 你不想设置那个字段
下面只例出几个式子

CRON表达式含义
"0 0 12 * * ?" 每天中午十二点触发
"0 15 10 ? * *" 每天早上10：15触发
"0 15 10 * * ?" 每天早上10：15触发
"0 15 10 * * ? *" 每天早上10：15触发
"0 15 10 * * ? 2005" 2005年的每天早上10：15触发
"0 * 14 * * ?" 每天从下午2点开始到2点59分每分钟一次触发
"0 0/5 14 * * ?" 每天从下午2点开始到2：55分结束每5分钟一次触发
"0 0/5 14,18 * * ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发
"0 0-5 14 * * ?" 每天14:00至14:05每分钟一次触发
"0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发
"0 15 10 ? * MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发

❺ java中spring框架定时任务怎么调试

java定时器的使用（） 1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。 private java.util.Timer timer; timer = new Timer(true); timer.sche.

❻ java 定时器怎么跟spring结合

java定时器的使用（）
1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。
对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。
private java.util.Timer timer;
timer = new Timer(true);
timer.schele(
new java.util.TimerTask() { public void run()
{ //server.checkNewMail(); 要操作的方法} }, 0, 5*60*1000);
第一个参数是要操作的方法，第二个参数是要设定延迟的时间，第三个参
数是周期的设定，每隔多长时间执行该操作。
使用这几行代码之后，Timer本身会每隔5分钟调用一遍
server.checkNewMail()方法，不需要自己启动线程。Timer本身也是多线程同
步的，多个线程可以共用一个Timer，不需要外部的同步代码。
2、
(1)Timer.schele(TimerTask task,Date time)安排在制定的时间执行指定的
任务。
(2)Timer.schele(TimerTask task,Date firstTime ,long period)安排指定
的任务在指定的时间开始进行重复的固定延迟执行．
(3)Timer.schele(TimerTask task,long delay)安排在指定延迟后执行指定的
任务．
(4)Timer.schele(TimerTask task,long delay,long period)安排指定的任务
从指定的延迟后开始进行重复的固定延迟执行．
(5)Timer.scheleAtFixedRate(TimerTask task,Date firstTime,long period)
安排指定的任务在指定的时间开始进行重复的固定速率执行．
(6)Timer.scheleAtFixedRate(TimerTask task,long delay,long period)安
排指定的任务在指定的延迟后开始进行重复的固定速率执行．
用Java Timer API 进行时间调度开发的相关注意点
java.util这个包中可以找到Timer和TimerTask这两个类。Timer直接从Object
继承，它相当于一个计时器，能够用它来指定某个时间来执行一项任务，或者
每隔一定时间间隔反复执行同一个任务。创建一个Timer后，就会生成一个线程
在背后运行，来控制任务的执行。而TimerTask就是用来实现某项任务的类，
它实现了Runnable接口，因此相当于一个线程。
Timer 的构造方法 new Timer(true)如果参数为 true 的话，这个线程就是一个守护线程，导致我在后面调用几个 timer.schele() 方法时，只有第一个被执行，后面几个都被屏蔽了，如果把这个参数设置为 false ，后面的调用才能生效。
如何实现自己的任务调度？
1、继承TimerTask，注意TimerTask是实现Runnable接口的，因此只要重载run()
方法即可。
2、创建Timer对象，调用schele()方法。
相关注意点分析：
1、任务调度要优先考虑实时保证
由于Java的天性，并且在开发JDK的过程中要考虑到不同平台，而不同平台的
线程调度机制是不同的，因此各种平台下JVM 的线程调度机制也是不一致的。
从而Timer不能保证任务在所指定的时间内执行。另外由于TimerTask是实现
Runnable接口的，在TimerTask被放进线程队列睡眠一段时间（wait）之后，
当到了指定的该唤起该TimerTask时，由于执行的确切时机取决于JVM的调度策
略和当前还有多少线程在等待CPU处理。因此就不能保证任务在所指定的时间
内执行。通常在如下两种情况下导致任务延迟执行：
（1）、有大量线程在等待执行
（2）、GC机制的影响导致延迟
这也是为什么在Timer API中存在两组调度方法的原因。即：
（1）、schele()
用固定延迟调度。使用本方法时，在任务执行中的每一个延迟会传播到后续的任
务的执行。
（2）、scheleAsFixedRate()
用固定比率调度。使用本方法时，所有后续执行根据初始执行的时间进行调度，
从而希望减小延迟。
具体使用哪一个方法取决于哪些参数对你的程序或系统更重要。
2、每个Timer对象要在后台启动一个线程。这种性质在一些托管的环境下不推
荐使用，比如在应用服务器中。因为这些线程不在容器的控制范围之内了。
具体Java API 中的Timer 类和TimerTask类的描述如下：
java.util
类Timer
java.lang.Object
java.util.Timer
public class Timer
extends Object
一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，
或者定期重复执行。
与每个Timer 对象相对应的是单个后台线程，用于顺序地执行所有计时器任务。
计时器任务应该迅速完成。如果完成某个计时器任务的时间太长，那么它会“独
占”计时器的任务执行线程。因此，这就可能延迟后续任务的执行，而这些任务
就可能“堆在一起”，并且在上述令人讨厌的任务最终完成时才能够被快速连续
地执行。
对Timer 对象最后的引用完成后，并且所有未处理的任务都已执行完成后，计
时器的任务执行线程会正常终止（并且成为垃圾回收的对象）。但是这可能要很
长时间后才发生。默认情况下，任务执行线程并不作为守护线程来运行，所以
它能够阻止应用程序终止。如果调用方想要快速终止计时器的任务执行线程，那
么调用方应该调用计时器的cancel 方法。
如果意外终止了计时器的任务执行线程，例如调用了它的stop 方法，那么所有
以后对该计时器安排任务的尝试都将导致IllegalStateException，就好像调用
了计时器的cancel 方法一样。
此类是线程安全的：多个线程可以共享单个Timer 对象而无需进行外部同步。
此类不提供实时保证：它使用Object.wait(long) 方法来安排任务。
实现注意事项：此类可扩展到大量同时安排的任务（存在数千个都没有问题）。
在内部，它使用二进制堆来表示其任务队列，所以安排任务的开销是O(log n)，
其中n 是同时安排的任务数。
实现注意事项：所有构造方法都启动计时器线程。
从以下版本开始：
1.3
另请参见：
TimerTask, Object.wait(long)
构造方法摘要
Timer()
创建一个新计时器。
Timer(boolean isDaemon)
创建一个新计时器，可以指定其相关的线程作为守护程序运行。
Timer(String name)
创建一个新计时器，其相关的线程具有指定的名称。
Timer(String name, boolean isDaemon)
创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运
行。
方法摘要
void cancel()
终止此计时器，丢弃所有当前已安排的任务。
int purge()
从此计时器的任务队列中移除所有已取消的任务。
void schele(TimerTask task, Date time)
安排在指定的时间执行指定的任务。
void schele(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定延迟执行。
void schele(TimerTask task, long delay)
安排在指定延迟后执行指定的任务。
void schele(TimerTask task, long delay, long period)
安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
void scheleAtFixedRate(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定速率执行。
void scheleAtFixedRate(TimerTask task, long delay, long period)
安排指定的任务在指定的延迟后开始进行重复的固定速率执行。
从类java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
构造方法详细信息
Timer
public Timer()
创建一个新计时器。相关的线程不作为守护程序运行。
另请参见：
Thread, cancel()
Timer
public Timer(boolean isDaemon)
创建一个新计时器，可以指定其相关的线程作为守护程序运行。如果计时器将用于
安排重复的“维护活动”，则调用守护线程，在应用程序运行期间必须调用守护线程，
但是该操作不应延长程序的生命周期。
参数：
isDaemon - 如果应该将相关的线程作为守护程序运行，则为true。
另请参见：
Thread, cancel()
Timer
public Timer(String name)
创建一个新计时器，其相关的线程具有指定的名称。相关的线程不作为守护程序运
行。
参数：
name - 相关线程的名称。
抛出：
NullPointerException - 如果name 为null。
从以下版本开始：
1.5
另请参见：
Thread.getName(), Thread.isDaemon()
Timer
public Timer(String name,
boolean isDaemon)
创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运
行。
参数：
name - 相关线程的名称。
isDaemon - 如果应该将相关的线程作为守护程序运行，则为true。
抛出：
NullPointerException - 如果name 为null。

❼ JAVA spring+quertz 定时任务每17秒执行一次

application-quartz.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:security="http://www.springframework.org/schema/security"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 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.0.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.0.xsd">

<task:annotation-driven />
<task:scheled-tasks>
<task:scheled ref="Job" method="process" cron="*/17 * * * *" />
</task:scheled-tasks>
</beans>

Job:
//注解
@Service("Job")
public class *Job {
public void process() throws ParseException {
}
}

❽ spring定时任务的几种实现

❾ java spring 定时任务自动审核声明式事务

你可以只用一个定时任务，每次取一个，然后进行处理，你也可以顺序得进行，也可以多线程，但是取过的记录最好在数据库上打个标记来区别。
还有种就是取一个列表，然后全插到一个队列里，另一线程就是用队列的阻塞原理来取对象来处理，没有就会阻塞在那里，同样建议你每次给取到的和处理掉的数据都打个标记（如果你是删除的就不说了）

❿ Spring定时任务的几种实现附实例

1、Java自带的java.util.Timer类，自定义一个类继承TimerTask

例子：

public class TestTimerTask {

Timer timer;

public TestTimerTask(int a) {
timer = new Timer();
timer.schele(new GoodTimerTask(),0, 1000*a);
}

public static void main(String[] args) {
System.out.println("About to schele task.");
new TestTimerTask(3);
}

class GoodTimerTask extends TimerTask{

@Override
public void run() {
System.out.println("Timer running!");
}

}
}

2、Spring3.0以后自带的task

//一、在applicationContext.xml配置的方式
//1、准备jar包
// (1)spring核心jar包
//2、在项目中写个类
@Service
public class BookScheleTask {

@Resource
private BookService bookService;

public Page<Book> findAllBook(){ //不带参数
System.out.println("BookScheleTask.findAllBook()");
return bookService.findBook(1);
}
}
//3、在ApplicationContext.xml配置文件中写如下配置：

<context:component-scan base-package="com" />


<task:scheled-tasks>
<task:scheled ref="bookScheleTask" method="findAllBook" cron="0 0 12 * * ?"/>
</task:scheled-tasks>

说明：(1)<context:component-scan base-package="com" />该配置，相信大家用过spring的都知道是什么意思，
是spring用于扫描注解的
(2)<task:scheled-tasks>,该配置的作用是定义一个时间计划任务，定义某个类下面某个方法在某个时间执行。
<task:scheled ref="bookScheleTask" method="findAllBook" cron="0 0 12 * * ?"/>，ref表示的是
某个要在规定时间执行的类，method表示要执行的类下的某个方法，cron表示时间表达式，具体详细的表达式
可以网络查询
//二、基于注解的spring定时器
// 1、同上，准备好spring的jar包
// 2、在项目中创建一个类，用于执行定时任务的类。如下：
@Component("bookScheleTask")
public class BookScheleTask {

@Resource
private BookService bookService;

@Scheled(cron="0 50 14 * * ?")
public void findAllBook(){
System.out.println("BookScheleTask.findAllBook()");
bookService.findBook(1);
}
}
// 说明：基于注解的方法，@Component("bookScheleTask")表示定义了一个别名。
// @Scheled(cron="0 50 14 * * ?")表示：该注解下的方法是一个时间任务，在cron="0 50 14 * * ?"（14:50）执行findAllBook()方法

3、使用quartz

//首先我们需要定义一个任务类，比如为MyJob02 ，
//该类需要继承Job类，然后添加execute(JobExecutionContext context)方法，在
//这个方法中就是我们具体的任务执行的地方。
//由希望由调度程序执行的组件实现的接口
public class MyJob02 implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
// TODO Auto-generated method stub
// 执行响应的任务.
System.out.println("HelloJob.execute,"+new Date());}}

public class QuartzTest5 {
public static void main(String[] args) throws Exception {
//SchelerFactory 是一个接口，用于Scheler的创建和管理
SchelerFactory factory = new StdSchelerFactory();
//从工厂里面拿到一个scheler实例//计划表(可能翻译的不太贴切)，现在我们有了要做的内容，
//与调度程序交互的主要API
/** Scheler的生命期，从SchelerFactory创建它时开始，
到Scheler调用shutdown()方法时结束；Scheler被创建后，可以增加、删除和列举Job和Trigger，
以及执行其它与调度相关的操作（如暂停Trigger）。但是，Scheler只有在调用start()方法后，
才会真正地触发trigger（即执行job）*/
Scheler scheler = factory.getScheler();
//具体任务.//用于定义作业的实例
//JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。
JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
//Trigger（即触发器） - 定义执行给定作业的计划的组件
//TriggerBuilder - 用于定义/构建触发器实例
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
.withSchele(CronScheleBuilder.cronSchele("0/1 * * * * ?")).build();
scheler.scheleJob(job, trigger);scheler.start();
}

导航:首页 > 编程语言 > java定时任务spring

java定时任务spring

与java定时任务spring相关的资料