Comment utiliser la classe Timer pour appeler une méthode, faire quelque chose, réinitialiser la minuterie, répéter?

Voulez-vous spécifiquement un Timer? Sinon, vous êtes probablement mieux avec un ScheduledExecutorService et en appelant scheduleAtFixedRate ou scheduleWithFixedDelay; en citant le Javadocs:

Java 5.0 a introduit le paquet java.util.concurrent et l'un des les utilitaires de concurrence y sont le ScheduledThreadPoolExecutor qui est un pool de threads pour l'exécution répétée de tâches à un rythme donné ou retard. C'est effectivement un remplacement plus souple pour le Timer/TimerTask combinaison, car elle permet plusieurs services threads, accepte différentes unités de temps et ne nécessite pas de sous-classement TimerTask (il suffit d'implémenter Runnable). Configuration de ScheduledThreadPoolExecutor avec un thread, cela équivaut à Timer.

Mise à JOUR

Voici un code de travail utilisant 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 sortie ressemble à:

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

Pensez à un scénario où je veux que mon code s'exécute à un moment donné dans mon application ou quelque temps plus tard à partir de l'heure actuelle. En d'autres termes, je veux planifier ma tâche à l'heure définie.

Java Timer classe (java.util.Timer) permet à une application de planifier la tâche sur un thread d'arrière-plan séparé.

Voici l'exemple le plus simple de 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

ANALYSE : L'appel à la minuterie.le calendrier (tâche, 10000,1000) est va planifier la tâche qui va s'exécuter pour la première fois (sur un autre thread) après 10 secondes de cet appel. Après cela, il appellera à nouveau après un délai de 10 secondes. Il est important de mentionner ici que si la tâche ne peut pas être démarrée après 10 secondes, le prochain appel de tâche ne sera pas pré-pond. Donc, ici, le temps de retard entre deux tâches consécutives est fixé.

Source: Exemple de temporisateur Java

Cette page a un bon exemple de l'utilisation de Timers et TimerTasks que vous pouvez ajuster à vos besoins.

Si vous ne voulez pas utiliser la classe timer et que vous pouvez utiliser Quartz, effectuez-le comme. Ma classe principale serait

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

    }






}

Et la classe de travail serait

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


}

Je créerais un pot exécutable pour cela et je commencerais cela en utilisant java -jar .. & et Ctrl+C peut arrêter ce processus, Si vous le voulez en arrière-plan disown it

Le code ci-dessous s'exécutera à 18h20 et il se répétera dans un intervalle de 5 secondes.

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