tiempo - timer java segundos

Cómo puedo ejecutar mi TimerTask todos los días a las 2 p.m.

Question

Quiero ejecutar un trabajo todos los días 2PM. ¿Qué método de java.util.Timer puedo usar para programar mi trabajo?

Después de 2 horas de ejecución, se detendrá el trabajo y se reprogramará para el día siguiente a las 2 p.m.

Answer 1

¿Por qué no utilizas @Scheduled de Spring (cron = "0 0 14 * * *") .. para seg, min, hours, day, month, dayOfWeek. V Cool Incluso puede especificar 9-11 para 9:00 a 11:00, o MON-FRI en el último parámetro. También puede invocar esto programáticamente, como es el caso de la mayor parte de Spring, en caso de que desee establecer la hora en tiempo de ejecución. Vea esto: - http://docs.spring.io/spring/docs/current/spring-framework-reference/html/scheduling.html

Agregar un ejemplo

   @Scheduled(cron="0 0 14 * * *")
    public void customScheduler(){
        try{
            // do what ever you want to run repeatedly
        }catch(Exception e){
            e.printStackTrace();

        }
    }

también anote la clase que contiene esto con la anotación @Component y proporcione @EnableScheduling en la clase Application.java (la clase contiene el método principal) para que Spring se dé cuenta de que está utilizando taskscheduler en su aplicación.

Answer 2

Debería intentar usar scheduleAtFixedRate (esto repetirá su tarea). Deberá crear un objeto TimerTask que especificará qué ejecutar (en run ()) y cuándo ejecutarse (scheduleExecutionTime). scheduleAtFixedRate también le permite especificar la primera fecha de ejecución.

Answer 3

Debido a java.util.Timer :

Java 5.0 introdujo el paquete java.util.concurrent y una de las utilidades de simultaneidad en el mismo es ScheduledThreadPoolExecutor, que es un grupo de subprocesos para ejecutar tareas repetidamente a una tasa o retraso dados. Es efectivamente un reemplazo más versátil para la combinación Timer / TimerTask, ya que permite múltiples hilos de servicio, acepta varias unidades de tiempo y no requiere la subclasificación de TimerTask (simplemente implemente Runnable). Configurar ScheduledThreadPoolExecutor con un hilo lo hace equivalente a Timer.

entonces (agrega este código a tu clase):

new ScheduledExecutor().scheduleRegularly(() -> {

    // do your task...

}, LocalDateTime.now().truncatedTo(ChronoUnit.DAYS).withHour(14), thisTime -> thisTime.plusDays(1));

Answer 4

La forma más fácil que he encontrado de hacer esto siempre ha sido a través del Programador de tareas en Windows y cron en Linux.

Sin embargo, para Java, eche un vistazo a Quartz Scheduler

De su sitio web:

Quartz es un servicio completo de programación de trabajos de código abierto que se puede integrar o utilizar junto con prácticamente cualquier aplicación Java EE o Java SE, desde la aplicación autónoma más pequeña hasta el sistema de comercio electrónico más grande. Quartz se puede usar para crear cronogramas simples o complejos para ejecutar decenas, cientos o incluso decenas de miles de trabajos; trabajos cuyas tareas se definen como componentes estándar de Java que pueden ejecutar prácticamente todo lo que pueda programar para que hagan. Quartz Scheduler incluye muchas características de clase empresarial, como transacciones JTA y clustering.

Answer 5

La mayoría de las respuestas para esta pregunta y las dos preguntas siguientes suponen que los milisegundos por día son siempre los mismos .
¿Cómo programar una tarea periódica en Java?
¿Cómo ejecutar determinada tarea todos los días en un momento determinado utilizando ScheduledExecutorService?

Sin embargo, no es posible debido al ahorro de luces diurnas y los segundos intercalares. Esto significa que si su servicio está activo durante años y la precisión del temporizador es importante, un temporizador de período fijo no es su elección.

Por lo tanto, me gustaría presentar mi fragmento de código para un temporizador más flexible que el java.util.Timer .

private ScheduledExecutorService scheduledExecutorService;

    public ScheduledSendLog() {
        init();
    }

    public void destroy() {
        this.scheduledExecutorService.shutdown();
    }

    private void init() {
        scheduledExecutorService =
                Executors.newScheduledThreadPool(1);
        System.out.println("---ScheduledSendLog created " + LocalDateTime.now());
        startSchedule(LocalTime.of(02, 00));
    }


    private void startSchedule(LocalTime atTime) {
        this.scheduledExecutorService.scheduleWithFixedDelay(() -> {
                    System.out.println(Thread.currentThread().getName() +
                            " |  scheduleWithFixedDelay | " + LocalDateTime.now());
                    // or whatever you want
                }, calculateInitialDelayInSec(atTime),
                LocalTime.MAX.toSecondOfDay(),
                TimeUnit.SECONDS);
    }

    private long calculateInitialDelayInSec(LocalTime atTime) {
        int currSec = LocalTime.now().toSecondOfDay();
        int atSec = atTime.toSecondOfDay();
        return (currSec < atSec) ?
                atSec - currSec : (LocalTime.MAX.toSecondOfDay() + atSec - currSec);

    }  

Luego, puede ejecutar su trabajo todos los días a las 2 p.m. al invocar el método anterior de la siguiente manera.

package szx;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.function.Function;

public class ScheduledExecutor {
    public void scheduleRegularly(Runnable task, LocalDateTime firstTime,
            Function<LocalDateTime, LocalDateTime> nextTime) {
        pendingTask = task;
        scheduleRegularly(firstTime, nextTime);
    }

    protected void scheduleRegularly(LocalDateTime firstTime,
            Function<LocalDateTime, LocalDateTime> nextTime) {
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                scheduleRegularly(nextTime.apply(firstTime), nextTime);
                pendingTask.run();
            }
        }, Date.from(firstTime.atZone(ZoneId.systemDefault()).toInstant()));
    }

    private volatile Runnable pendingTask = null;
}

La idea básica detrás del código es recalcular el tiempo restante para el siguiente tick y comenzar un nuevo temporizador cada vez.

Answer 6

Puede utilizar el Timer.schedule(TimerTask task, Date firstTime, long period) , establecer firstTime a las 2 firstTime de hoy y establecer el period en 24 horas:

Programa la tarea especificada para la ejecución repetida de retardo fijo, a partir de la hora especificada. Las ejecuciones posteriores tienen lugar aproximadamente a intervalos regulares, separadas por el período especificado.

Answer 7

usar un calendario público vacío (tarea TimerTask, fecha firstTime, período largo)

para hacer que la tarea se repita de nuevo al día siguiente, solo establezca el período en 86400000 milisegundos (lo que significa 1 día)

Date date2pm = new java.util.Date();
date2pm.setHour(14);
date2pm.setMinutes(0);

Timer timer = new Timer();

timer.sc(myOwnTimerTask,date2pm, 86400000);

Answer 8

Calendar today = Calendar.getInstance();
today.set(Calendar.HOUR_OF_DAY, 2);
today.set(Calendar.MINUTE, 0);
today.set(Calendar.SECOND, 0);

// every night at 2am you run your task
Timer timer = new Timer();
timer.schedule(new YourTask(), today.getTime(), TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS)); // period: 1 day

Answer 9

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Timer;
import java.util.TimerTask;


public class MyTimerTask extends TimerTask {
    private final static long ONCE_PER_DAY = 1000*60*60*24;

    //private final static int ONE_DAY = 1;
    private final static int TWO_AM = 2;
    private final static int ZERO_MINUTES = 0;


    @Override
    public void run() {
        long currennTime = System.currentTimeMillis();
        long stopTime = currennTime + 2000;//provide the 2hrs time it should execute 1000*60*60*2
          while(stopTime != System.currentTimeMillis()){
              // Do your Job Here
            System.out.println("Start Job"+stopTime);
            System.out.println("End Job"+System.currentTimeMillis());
          }
    }
    private static Date getTomorrowMorning2AM(){

        Date date2am = new java.util.Date(); 
           date2am.setHours(TWO_AM); 
           date2am.setMinutes(ZERO_MINUTES); 

           return date2am;
      }
    //call this method from your servlet init method
    public static void startTask(){
        MyTimerTask task = new MyTimerTask();
        Timer timer = new Timer();  
        timer.schedule(task,getTomorrowMorning2AM(),1000*10);// for your case u need to give 1000*60*60*24
    }
    public static void main(String args[]){
        startTask();

    }

}