Como usar a class Timer para chamar um método, fazer algo, redefinir timer, repetir?

Eu sou um iniciante em Java e tenho andado por aí com várias soluções para este problema e tenho me dado um nó. Eu tentei com threads e, em seguida, descobri esta class Timer e ter mexido com ele sem sucesso até agora. Se você pudesse postar código executável com um método principal para que eu pudesse vê-lo funcionando e começar a brincar de lá, seria ótimo.

  1. Programa de lançamento
  2. chamar doSomething()
  3. Gere um número random e defina o Timer por tanto tempo.
  4. Quando o timer se apagar, chame doSomething() novamente.

Provavelmente usando isso: http://docs.oracle.com/javase/6/docs/api/java/util/Timer.html

Se você quiser simplesmente usar o Timer, eu faria algo assim:

 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 } } 

Desculpe pela má identificação.

Além disso, se você precisar programar a execução do código, dê uma olhada no Guava Services, pois ele pode realmente tornar seu código muito mais claro e abstrair um pouco do clichê de criação de threads, agendamento, etc.

A propósito, não me dei ao trabalho de gerar números randoms, etc., mas acho que você pode descobrir como include essa parte. Espero que isso seja o suficiente para você entrar no caminho certo.

Para o registro, se você fosse usar o Guava, seria algo como isto:

 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); } }; } } 

E você simplesmente criaria um main que chamou new CrawlingService.start (); é isso aí.

Você quer especificamente um Timer ? Se não, você provavelmente está melhor com um ScheduledExecutorService e chamando scheduleAtFixedRate ou scheduleWithFixedDelay ; citando os Javadocs :

O Java 5.0 introduziu o pacote java.util.concurrent e um dos utilitários de simultaneidade é o ScheduledThreadPoolExecutor que é um conjunto de encadeamentos para executar repetidamente tarefas em uma determinada taxa ou atraso. É efetivamente um substituto mais versátil para a combinação Timer / TimerTask , já que permite vários encadeamentos de serviço, aceita várias unidades de tempo e não requer o TimerTask subsorting (basta implementar o Runnable ). Configurar o ScheduledThreadPoolExecutor com um thread faz com que seja equivalente ao Timer .

ATUALIZAR

Aqui está um código de trabalho usando um 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); } } 

A saída é semelhante a:

 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 

Pense em um cenário no qual eu quero que meu código seja executado em um determinado momento em meu aplicativo ou em algum momento posterior a partir do horário atual. Em outras palavras, quero agendar minha tarefa no horário definido.

A class Java Timer (java.util.Timer) permite que um aplicativo agende a tarefa em um thread de segundo plano separado.

Aqui está o exemplo mais simples do 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 

ANÁLISE: A chamada para timer.schedule (tarefa, 10000, 1000) vai agendar a tarefa que será executada pela primeira vez (em outro segmento) após 10 segundos desta chamada. Depois disso, ele irá ligar novamente após o atraso de 10 segundos. É importante mencionar aqui que, se a tarefa não puder ser iniciada após 10 segundos, a próxima chamada de tarefa não terá prioridade. Então aqui o tempo de atraso entre duas tarefas consecutivas é fixo.

Fonte: Exemplo de timer Java

Esta página tem um bom exemplo do uso de Timer e TimerTask que você pode ajustar para suas necessidades.

Se você não quiser usar a class timer e pode usar o Quartz, faça o mesmo. Minha aula principal seria

 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(); } } })); } } 

e class de trabalho seria

 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!"); } } 

Gostaria de criar um jar executável para isso e começar isso usando java -jar .. & e Ctrl+C pode parar esse processo, se você quiser no fundo disown isso

O código abaixo será executado às 18:20 e irá repetir-se no intervalo de 5 seg.

 public static void main(String[] args) { Timer timer = new Timer(); TimerTask tt = new TimerTask() { public void run() { Calendar cal = Calendar.getInstance(); int hour = cal.get(Calendar.HOUR_OF_DAY); int min = cal.get(Calendar.MINUTE); if (hour == 18 && min == 20) { doSomething(); } } }; timer.schedule(tt, 1000, 5000); }