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相關的資料