Java定时任务的三种实现方式

秒速五厘米 2022-04-12 10:14 208阅读 0赞

第一种：

package com.timertask.test;
    
    /**
     * 三种方式实现java定时任务
     * @author li
     *
     */
    public class TimerTask {
    
    	static int i = 1;
    	public static void main(String[] args) {
    		/** 
    		 * 普通thread 
    		 * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着， 
    		 * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下： 
    		 * @author li
    		 * 
    		 */ 
    		final long timeInterval = 3000;
    		Runnable runnable = new Runnable(){
    
    			@Override
    			public void run() {
    				while(true){
    					System.out.println(i+"、Hello LingGe!");
    					i++;
    					
    					try {
    						Thread.sleep(timeInterval);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    				
    			}
    			
    		};
    		
    		Thread thread = new Thread(runnable);
    		thread.start();
    	}
    
    }

执行结果：

1、Hello LingGe!
    2、Hello LingGe!
    3、Hello LingGe!
    4、Hello LingGe!
    5、Hello LingGe!
    6、Hello LingGe!
    7、Hello LingGe!
    8、Hello LingGe!
    9、Hello LingGe!
    10、Hello LingGe!
    
    每三秒执行一次

第二种：

package com.timertask.test;
    
    import java.util.Timer;
    import java.util.TimerTask;
    
    /**
     * 三种方式实现java定时任务
     * @author li
     *
     */
    public class TimerTask2 {
    
    	static int i = 1;
    	public static void main(String[] args) {
    		/** 
    		 *  
    		 * 于第一种方式相比，优势 1>当启动和去取消任务时可以控制 2>第一次执行任务时可以指定你想要的delay时间 
    		 *  
    		 * 在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。 Timer实例可以调度多任务，它是线程安全的。 
    		 * 当Timer的构造器被调用时，它创建了一个线程，这个线程可以用来调度任务。 下面是代码： 
    		 *  
    		 * @author GT 
    		 *  
    		 */
    		final Timer timer = new Timer();
    		TimerTask task = new TimerTask(){
    
    			@Override
    			public void run() {
    				System.out.println("Hello LingGe!!");
    				//退出任务
    				timer.cancel();
    			}
    			
    		};
    		
    		//延迟指定的时间执行，单位毫秒
    		long delay = 5000;
    		long intervalPeriod = 1*3000;
    		timer.schedule(task, delay);
    		//timer.scheduleAtFixedRate(task, delay, intervalPeriod);
    		
    	}
    	
    	
    
    }

第三种：

package com.timertask.test;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 三种方式实现java定时任务
     * @author li
     *
     */
    public class TimerTask3 {
    
    	static int i = 1;
    	public static void main(String[] args) throws InterruptedException {
    		/** 
    		 *  
    		 *  
    		 * ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。  
    		 * 相比于上两个方法，它有以下好处： 
    		 * 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的  
    		 * 2>可以很灵活的去设定第一次执行任务delay时间 
    		 * 3>提供了良好的约定，以便设定执行的时间间隔 
    		 *  
    		 * 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。 
    		 *  
    		 *  
    		 * @author GT 
    		 *  
    		 */ 
    		final long timeInterval = 3000;
    		Runnable runnable = new Runnable(){
    
    			@Override
    			public void run() {
    				while(true){
    					System.out.println(i+"、Hello LingGe!_"+Thread.currentThread().getId());
    					i++;
    					
    					try {
    						Thread.sleep(timeInterval);
    					} catch (InterruptedException e) {
    						
    						e.printStackTrace();
    					}
    				}
    				
    			}
    			
    		};
    		//构造一个线程池（我猜的）
    		ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
    		// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间 
    		service.scheduleAtFixedRate(runnable, 5, 3, TimeUnit.SECONDS);
    		service.scheduleAtFixedRate(runnable, 2, 3, TimeUnit.SECONDS);
    		
    	}
    }

结果：

1、Hello LingGe!_9
    2、Hello LingGe!_10
    3、Hello LingGe!_9
    4、Hello LingGe!_10
    5、Hello LingGe!_9
    6、Hello LingGe!_10
    7、Hello LingGe!_9
    8、Hello LingGe!_10
    9、Hello LingGe!_9
    10、Hello LingGe!_10
    11、Hello LingGe!_9