Cómo usar la clase del temporizador para llamar a un método, hacer algo, reiniciar el temporizador, repetir?

Question

Soy un principiante de Java y he estado dando vueltas con varias soluciones a este problema y me he anudado un poco. Lo intenté con Threads y luego descubrí esta clase de Timer y me he equivocado con ella hasta ahora. Si pudieras publicar el código ejecutable con un método principal para poder verlo funcionar y empezar a jugar desde allí, sería genial.

programa de lanzamiento
1. llamada doSomething()
2. Generar números aleatorios y establecer un temporizador para que a largo
3. .
4. Cuando el temporizador se apaga, llame de nuevo al doSomething().

Probablemente el uso de este: http://docs.oracle.com/javase/6/docs/api/java/util/Timer.html

Answer 1

Si desea simplemente utilice el temporizador, lo haría haz algo como esto:

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

Perdón por la pésima identación.

Además, si necesita programar la ejecución de código, echar un vistazo a Guava Services ya que realmente puede hacer que el código mucho más claro y abstracto un poco de la plancha de caldera de crear hilos, programación, etc.

Por Por cierto, no me tomé la molestia de generar un número aleatorio, etc., pero creo que puedes averiguar cómo incluir esa parte. Espero que esto sea suficiente para llevarte por el camino correcto.

Para el registro, si se fuera a utilizar guayaba, se vería algo como esto:

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

Y sólo tendría que crear una nueva principal que llama CrawlingService.start(); Eso es.

Answer 2

This page tiene un buen ejemplo del uso de Timer s y s TimerTask que se puede ajustar con precisión para sus necesidades.

Answer 3

¿Desea específicamente un Timer? Si no, probablemente esté mejor con un ScheduledExecutorService y llame al scheduleAtFixedRate o scheduleWithFixedDelay; citando el Javadocs:

Java 5.0 introdujo el paquete java.util.concurrent y uno de los utilidades de concurrencia en él la ScheduledThreadPoolExecutor que es un grupo de subprocesos para ejecutar repetidamente tareas a una velocidad dada o demora. En efecto, es un sustituto más versátil para la combinación Timer/TimerTask, ya que permite que múltiples hilos de servicio, Admisión de distintas unidades de tiempo, y no requiere la creación de subclases TimerTask (justo aplicar Runnable). Configurar ScheduledThreadPoolExecutor con un hilo lo hace equivalente a Timer.

ACTUALIZACIÓN

Aquí hay un código de trabajo utilizando un 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); 
    } 
} 

La salida será similar 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 

Answer 4

Piense en un escenario en el que deseo que mi código se ejecute en un momento determinado de mi aplicación o más tarde a partir de la hora actual. En otras palabras, quiero programar mi tarea en el tiempo definido.

Java Timer clase (java.util.Timer) permite que una aplicación programe la tarea en una secuencia de fondo separada.

Aquí es el más simple 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 

ANÁLISIS: La llamada a timer.schedule (tarea, 10000,1000) va a programar la tarea que se va a ejecutar por primera vez (en otro hilo) después de 10 segundos de esta llamada. Después de eso, volverá a llamar después de un retraso de 10 segundos. Es importante mencionar aquí que si la tarea no se puede iniciar después de 10 segundos, la próxima llamada a la tarea no se realizará antes del estanque. Entonces aquí el tiempo de demora entre dos tareas consecutivas es fijo.

Fuente: Java Timer Example

Answer 5

Si no desea utilizar la clase temporizador y puede utilizar cuarzo y luego realizarlo similares. Mi clase principal sería

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

    } 






} 

y clase de trabajo sería

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


} 

me gustaría crear un jar ejecutable para esto y empezar esta usando java -jar .. & y Ctrl+C puede detener ese proceso, si usted quiere que en el fondo disown es