如何使用Timer類來調用方法，執行某些操作，重置計時器，重複？

Question

我是一個Java初學者，一直在解決這個問題的各種解決方案，並得到了一種打結。我已經嘗試過使用線程，然後發現了這個Timer類，並且迄今爲止都沒有成功。如果你可以用主要方法發佈可執行代碼，所以我可以看到它的工作原理，並從那裏開始玩，那太棒了。

1. 啓動程序
2. 呼叫doSomething()
3. 生成隨機數，並長期爲設置定時器。
4. 定時器關閉時，請再次撥打doSomething()。

可能使用這樣的：http://docs.oracle.com/javase/6/docs/api/java/util/Timer.html

Answer 1

如果你想簡單地使用定時器，我會做這樣的事情：

public class TestClass { 
    public long myLong = 1234; 

    public static void main(String[] args) { 
     final TestClass test = new TestClass(); 

     Timer timer = new Timer(); 
     timer.schedule(new TimerTask() { 

      @Override 
      public void run() { 
       test.doStuff(); 
      } 
     }, 0, test.myLong); 
    } 

    public void doStuff(){ 
     //do stuff here 
    } 
} 

對不起，糟糕的身份。

另外，如果你需要安排的執行代碼，看看Guava Services，因爲它真的可以讓你的代碼更清晰，抽象頗有幾分創建線程，調度的樣板，等

通過順便說一句，我沒有費力地生成隨機數等，但我認爲你可以弄清楚如何包含該部分。我希望這足以讓你走上正軌。

爲了記錄在案，如果你使用番石榴，它會是這個樣子：

class CrawlingService extends AbstractScheduledService { 

    @Override 
    protected void runOneIteration() throws Exception { 
     //run this alot 
    } 

    @Override 
    protected void startUp() throws Exception { 
     //anything you need to step up 
    } 

    @Override 
    protected void shutDown() throws Exception { 
     //anything you need to tear down 
    } 


    @Override 
    protected Scheduler scheduler() { 
     return new CustomScheduler() { 
      @Override 
      protected Schedule getNextSchedule() throws Exception { 
       long a = 1000; //number you can randomize to your heart's content 
       return new Schedule(a, TimeUnit.MILLISECONDS); 
      } 
     }; 
    } 
} 

而且您只需創建一個主調用新CrawlingService.start（）;而已。

Answer 2

This page具有使用Timer S和TimerTask是你們等可以微調您的需求的一個很好的例子。

Answer 3

您是否需要Timer？如果不是，你可能更好用ScheduledExecutorService並呼籲scheduleAtFixedRate或scheduleWithFixedDelay;引述Javadocs：

爪哇5.0引入的java.util.concurrent包和的 併發工具一個在其中是ScheduledThreadPoolExecutor其 是用於在給定速率或 延遲反覆執行任務的線程池。這實際上是對 Timer/TimerTask組合更靈活的替代品，因爲它允許多個服務線程， 接受各種時間單位，且不需要子類TimerTask （只實現Runnable）。使用一個線程配置ScheduledThreadPoolExecutor 使其等效於Timer。

UPDATE

下面是使用一些工作代碼ScheduledExecutorService：

import java.util.Date; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.TimeUnit; 

public class Test { 
    public static void main(String[] args) { 
     final ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor(); 
     ses.scheduleWithFixedDelay(new Runnable() { 
      @Override 
      public void run() { 
       System.out.println(new Date()); 
      } 
     }, 0, 1, TimeUnit.SECONDS); 
    } 
} 

輸出看起來像：

Thu Feb 23 21:20:02 HKT 2012 
Thu Feb 23 21:20:03 HKT 2012 
Thu Feb 23 21:20:04 HKT 2012 
Thu Feb 23 21:20:05 HKT 2012 
Thu Feb 23 21:20:06 HKT 2012 
Thu Feb 23 21:20:07 HKT 2012 

Answer 4

想象一下我希望我的代碼在我的應用程序的某個特定時間執行或在當前時間稍後的某個時間執行的場景。換句話說，我想在特定的時間安排我的任務。

Java Timer class（java.util.Timer）允許應用程序在單獨的後臺線程上調度任務。

這是最簡單的example of Java Timer：

import java.util.Timer; 
import java.util.TimerTask; 
public class JavaTimer { 
    public static void main(String[] args){ 
    Timer timer = new Timer(); 
    TimerTask task = new TimerTask() { 
     @Override 
    public void run() { 
    System.out.println("Inside Timer Task" + System.currentTimeMillis()); 
     } 
    }; 

    System.out.println("Current time" + System.currentTimeMillis()); 
    timer.schedule(task, 10000,1000); 
    System.out.println("Current time" + System.currentTimeMillis()); 

    } 
} 

---

Output: 
Current time1455469505220 
Current time1455469505221 
Inside Timer Task1455469515222 
Inside Timer Task1455469516222 
Inside Timer Task1455469517222 
Inside Timer Task1455469518222 
Inside Timer Task1455469519222 
Inside Timer Task1455469520222 
Inside Timer Task1455469521222 
Inside Timer Task1455469522222 
Inside Timer Task1455469523222 
Inside Timer Task1455469524222 
Inside Timer Task1455469525222 
Inside Timer Task1455469526222 
Inside Timer Task1455469527222 
Inside Timer Task1455469528223 
Inside Timer Task1455469529223 and it goes on 

分析： 到timer.schedule調用（任務，10000,1000）將要安排的任務，是要執行第一次（在另一個線程上）在這次通話10秒後。之後，它會在延遲10秒後再次呼叫。這裏要提到的是，如果任務在10秒後不能啓動，下一個任務將不會啓動。所以這裏兩個連續任務之間的延遲時間是固定的。

來源：Java Timer Example

Answer 5

如果你不想使用定時器類，並可以使用Quartz然後像執行它。我的主要類將是

import com.google.common.util.concurrent.AbstractScheduledService; 
import org.quartz.CronScheduleBuilder; 
import org.quartz.JobBuilder; 
import org.quartz.JobDetail; 
import org.quartz.impl.StdSchedulerFactory; 
import org.quartz.*; 
import org.quartz.impl.StdSchedulerFactory; 
import static org.quartz.TriggerBuilder.newTrigger; 

import java.util.concurrent.CountDownLatch; 

public class Test { 


    public static void main(String[] args) throws Exception{ 


     CountDownLatch latch = new CountDownLatch(1); 


     //do schdeuling thing 
     JobDetail job = JobBuilder.newJob(SimpleJob.class).withIdentity(
       "CronQuartzJob", "Group").build(); 

     // Create a Trigger that fires every 5 minutes. 
     Trigger trigger = newTrigger() 
       .withIdentity("TriggerName", "Group") 
       .withSchedule(CronScheduleBuilder.cronSchedule("0/1 * * * * ?")) 
       .build(); 

     // Setup the Job and Trigger with Scheduler & schedule jobs 
     final Scheduler scheduler = new StdSchedulerFactory().getScheduler(); 
     scheduler.start(); 
     scheduler.scheduleJob(job, trigger); 

     // 
     latch.await(); 

     Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() { 
      @Override 
      public void run() { 
       try { 
        scheduler.shutdown(); 
        latch.countDown(); 
       }catch (Exception e){ 
        e.printStackTrace(); 
       } 
      } 
     })); 

    } 






} 

和作業類是

import org.quartz.Job; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 

public class SimpleJob implements Job { 


    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
     System.out.println("executing task!"); 
    } 


} 

我將建立一個可執行的JAR文件，這和使用java -jar .. &和Ctrl+C可以停止這個過程中，如果你想在後臺啓動此disown it