java的定時任務調度

⑴ java 定時任務的幾種實現方式

1. JDK 自帶的定時器實現

   // schele(TimerTask task, long delay) 延遲 delay 毫秒 執行
   // schele(TimerTask task, Date time) 特定時間執行
   public static void main(String[] args) {
   for (int i = 0; i < 10; ++i) {
   new Timer("timer - " + i).schele(new TimerTask() {
   @Override
   public void run() {
   println(Thread.currentThread().getName() + " run ");
   }
   }, 1000);
   }
   }
   2. 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();
   
   
   }
   3. Spring boot 任務調度(這個非常容易實現)

   /*
   * 開啟對定時任務的支持
   * 在相應的方法上添加@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++);
   }
   

⑵ java的幾種定時任務

java定時任務有三種：

- JDK自帶 ：JDK自帶的Timer以及JDK1.5+ 新增的ScheledExecutorService；

- Quartz ：簡單卻強大的JAVA作業調度框架

- Spring3.0以後自帶的task ：可以將它看成一個輕量級的Quartz，而且使用起來比Quartz簡單許多；

代碼參考：

1. JDK 自帶的定時器實現

   schele(TimerTask task, Date time) 特定時間執行

   
   public static void main(String[] args) {

   
   for (int i = 0; i < 10; ++i) {

   
   new Timer("timer - " + i).schele(new TimerTask() {

   
   @Override
   public void run() {

   
   println(Thread.currentThread().getName() + " run ");

   
   }

   
   }, new Date(System.currentTimeMillis() + 2000));

   
   }
   }

2. Quartz 定時器實現

   2.1 通過maven引入依賴（這里主要介紹2.3.0） 注意：shiro-scheler中依賴的是1.x版本 如果同時使用會沖突

   <!-- https://mvnrepository.com/artifact/org.quartz-scheler/quartz -->

   
   <dependency>

   
   <groupId>org.quartz-scheler</groupId>

   
   <artifactId>quartz</artifactId>

   
   <version>2.3.0</version>

   
   </dependency>

   2.2創建Job類

   public class TestJob implements Job{

   
   @Override
   public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

   
   println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());

   
   }
   }

   2.3調度任務

   public static void main(String[] args) throws InterruptedException, SchelerException {
   

   
   Scheler scheler = new StdSchelerFactory().getScheler();

   
   // 開始

   
   scheler.start();

   
   // job 唯一標識 test.test-1

   
   JobKey jobKey = new JobKey("test" , "test-1");

   
   JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();

   
   Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("test" , "test")

// 延遲一秒執行

.startAt(new Date(System.currentTimeMillis() + 1000))

// 每隔一秒執行 並一直重復

.withSchele(SimpleScheleBuilder.simpleSchele().withIntervalInSeconds(1).repeatForever())
.build();

scheler.scheleJob(jobDetail , trigger);

Thread.sleep(5000);
// 刪除job

scheler.deleteJob(jobKey);

}

3.Spring 相關的任務調度

3.1 配置文件實現

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

<task:scheled-tasks scheler="myScheler">

<task:scheled ref="job" method="test" cron="0 * * * * ?"/>

</task:scheled-tasks>

3.2註解實現

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

// 啟用註解

<task:annotation-driven scheler="myScheler"/>

@Component
public class Task{

@Scheled(cron="0/5 * * * * ? ") //每5秒執行一次
public void execute(){

DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println(sdf.format(DateTime.now().toDate())+"*********B任務每5秒執行一次進入測試");

}
}

⑶ java定時任務怎麼實現

/**
* 普通thread
* 這是最常見的，創建一個thread，然後讓它在while循環里一直運行著，
* 通過sleep方法來達到定時任務的效果。這樣可以快速簡單的實現，代碼如下：
* @author GT
*
*/
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();
}
}
[java] view plain
import java.util.Timer;
import java.util.TimerTask;
/**
*
* 於第一種方式相比，優勢 1>當啟動和去取消任務時可以控制 2>第一次執行任務時可以指定你想要的delay時間
*
* 在實現時，Timer類可以調度任務，TimerTask則是通過在run()方法里實現具體任務。 Timer實例可以調度多任務，它是線程安全的。
* 當Timer的構造器被調用時，它創建了一個線程，這個線程可以用來調度任務。 下面是代碼：
*
* @author GT
*
*/
public class Task2 {
public static void main(String[] args) {
TimerTask task = new TimerTask() {
@Override
public void run() {
// task to run goes here
System.out.println("Hello !!!");
}
};
Timer timer = new Timer();
long delay = 0;
long intevalPeriod = 1 * 1000;
// scheles the task to be run in an interval
timer.scheleAtFixedRate(task, delay, intevalPeriod);
} // end of main
}
[java] view plain
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
/**
*
*
* ScheledExecutorService是從Java SE5的java.util.concurrent里，做為並發工具類被引進的，這是最理想的定時任務實現方式。
* 相比於上兩個方法，它有以下好處：
* 1>相比於Timer的單線程，它是通過線程池的方式來執行任務的
* 2>可以很靈活的去設定第一次執行任務delay時間
* 3>提供了良好的約定，以便設定執行的時間間隔
*
* 下面是實現代碼，我們通過ScheledExecutorService#scheleAtFixedRate展示這個例子，通過代碼里參數的控制，首次執行加了delay時間。
*
*
* @author GT
*
*/
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 !!");
}
};
ScheledExecutorService service = Executors
.();
// 第二個參數為首次執行的延時時間，第三個參數為定時執行的間隔時間
service.scheleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
}
}

⑷ JAVA實現定時任務的幾種方式

Java 基本的定時任務，總結方法有三種：

1 創建一個thread，然後讓它在while循環里一直運行著，通過sleep方法來達到定時任務的效果；

2 用Timer和TimerTask與第一種方法相比有如下好處：

• 當啟動和去取消任務時可以控制

• 第一次執行任務時可以指定你想要的delay時間

3 用ScheledExecutorService是從的java.util.concurrent里，做為並發工具類被引進的，這是最理想的定時任務實現方式，相比於上兩個方法，它有以下好處：

• 相比於Timer的單線程，它是通過線程池的方式來執行任務的

• 可以很靈活的去設定第一次執行任務delay時間

• 提供了良好的約定，以便設定執行的時間間隔

⑸ 如何使用Java線程執行定時任務及線程調動和同步

class Mytask1 extends Timertask { ①

public void run（） {

System.out.println(」5 秒之後執行的定時器「）；

}

}

Class Mytask2 extends Timertask {

public void run（）{

System .out，println(」每秒執行的定時器」)；

}

}

class Mytask3 extends Timertask {

public void run (） {

System.out.println(」從某日起每分鍾執行的定時器!」) ;

}

}

public class TimerDemo {

plublic static void main(String[] args) {

Timer timer = new Timer( ) ; ②

timer.schele(new Mytask1( ) ,5000）; ③

timer,schele(new Mytask1( ) ,1000,1000) ; ④

timer,schele(new Mytask1( ) ,new Dateo ( ) , 1000 * 60) ; ⑤

}

}