1. 程式人生 > >java的三種實現定時任務的方法

java的三種實現定時任務的方法

  1. /** 
  2.  * 普通thread 
  3.  * 這是最常見的,建立一個thread,然後讓它在while迴圈裡一直執行著, 
  4.  * 通過sleep方法來達到定時任務的效果。這樣可以快速簡單的實現,程式碼如下: 
  5.  * @author GT 
  6.  * 
  7.  */  
  8. public class Task1 {  
  9.     public static void main(String[] args) {  
  10.         // run in a second  
  11.         final long timeInterval = 
    1000;  
  12.         Runnable runnable = new Runnable() {  
  13.             public void run() {  
  14.                 while
     (true) {  
  15.                     // ------- code for task to run  
  16.                     System.out.println("Hello !!");  
  17.                     // ------- ends here  
  18.                     try {  
  19.                         Thread.sleep(timeInterval);  
  20.                     } catch (InterruptedException e) {  
  21.                         e.printStackTrace();  
  22.                     }  
  23.                 }  
  24.             }  
  25.         };  
  26.         Thread thread = new Thread(runnable);  
  27.         thread.start();  
  28.     }  
  29. }  


[java]  view plain  copy
  1. import java.util.Timer;  
  2. import java.util.TimerTask;  
  3.   
  4. /** 
  5.  *  
  6.  * 於第一種方式相比,優勢 1>當啟動和去取消任務時可以控制 2>第一次執行任務時可以指定你想要的delay時間 
  7.  *  
  8.  * 在實現時,Timer類可以排程任務,TimerTask則是通過在run()方法裡實現具體任務。 Timer例項可以排程多工,它是執行緒安全的。 
  9.  * 當Timer的構造器被呼叫時,它建立了一個執行緒,這個執行緒可以用來排程任務。 下面是程式碼: 
  10.  *  
  11.  * @author GT 
  12.  *  
  13.  */  
  14. public class Task2 {  
  15.     public static void main(String[] args) {  
  16.         TimerTask task = new TimerTask() {  
  17.             @Override  
  18.             public void run() {  
  19.                 // task to run goes here  
  20.                 System.out.println("Hello !!!");  
  21.             }  
  22.         };  
  23.         Timer timer = new Timer();  
  24.         long delay = 0;  
  25.         long intevalPeriod = 1 * 1000;  
  26.         // schedules the task to be run in an interval  
  27.         timer.scheduleAtFixedRate(task, delay, intevalPeriod);  
  28.     } // end of main  
  29. }  

[java]  view plain  copy
  1. import java.util.concurrent.Executors;  
  2. import java.util.concurrent.ScheduledExecutorService;  
  3. import java.util.concurrent.TimeUnit;  
  4.   
  5. /** 
  6.  *  
  7.  *  
  8.  * ScheduledExecutorService是從Java SE5的java.util.concurrent裡,做為併發工具類被引進的,這是最理想的定時任務實現方式。  
  9.  * 相比於上兩個方法,它有以下好處: 
  10.  * 1>相比於Timer的單執行緒,它是通過執行緒池的方式來執行任務的  
  11.  * 2>可以很靈活的去設定第一次執行任務delay時間 
  12.  * 3>提供了良好的約定,以便設定執行的時間間隔 
  13.  *  
  14.  * 下面是實現程式碼,我們通過ScheduledExecutorService#scheduleAtFixedRate展示這個例子,通過程式碼裡引數的控制,首次執行加了delay時間。 
  15.  *  
  16.  *  
  17.  * @author GT 
  18.  *  
  19.  */  
  20. public class Task3 {  
  21.     public static void main(String[] args) {  
  22.         Runnable runnable = new Runnable() {  
  23.             public void run() {  
  24.                 // task to run goes here  
  25.                 System.out.println("Hello !!");  
  26.             }  
  27.         };  
  28.         ScheduledExecutorService service = Executors  
  29.                 .newSingleThreadScheduledExecutor();  
  30.         // 第二個引數為首次執行的延時時間,第三個引數為定時執行的間隔時間  
  31.         service.scheduleAtFixedRate(runnable, 101, TimeUnit.SECONDS);  
  32.     }  
  33. }