अनुसूचित शेड्यूलर सेवा का उपयोग करके किसी विशेष समय में हर दिन कुछ कार्य कैसे चलाया जाता है?

90

मैं रोज सुबह 5 बजे एक निश्चित कार्य चलाने की कोशिश कर रहा हूं। इसलिए मैंने इसके लिए उपयोग करने का फैसला किया, ScheduledExecutorServiceलेकिन अब तक मैंने ऐसे उदाहरण देखे हैं जिनसे पता चलता है कि हर कुछ मिनट में कार्य कैसे चलाना है।

और मुझे कोई उदाहरण नहीं मिल रहा है, जो यह दर्शाता है कि किसी कार्य को हर दिन किसी विशेष समय (सुबह 5 बजे) कैसे चलाया जाता है और साथ ही दिन के समय की बचत के तथ्य पर भी विचार किया जाता है -

नीचे मेरा कोड है जो हर 15 मिनट में चलेगा - 

public class ScheduledTaskExample {
    private final ScheduledExecutorService scheduler = Executors
        .newScheduledThreadPool(1);

    public void startScheduleTask() {
    /**
    * not using the taskHandle returned here, but it can be used to cancel
    * the task, or check if it's done (for recurring tasks, that's not
    * going to be very useful)
    */
    final ScheduledFuture<?> taskHandle = scheduler.scheduleAtFixedRate(
        new Runnable() {
            public void run() {
                try {
                    getDataFromDatabase();
                }catch(Exception ex) {
                    ex.printStackTrace(); //or loggger would be better
                }
            }
        }, 0, 15, TimeUnit.MINUTES);
    }

    private void getDataFromDatabase() {
        System.out.println("getting data...");
    }

    public static void main(String[] args) {
        ScheduledTaskExample ste = new ScheduledTaskExample();
        ste.startScheduleTask();
    }
}

क्या कोई रास्ता है, मैं दिन ScheduledExecutorServiceके उजाले के समय के साथ-साथ समय की बचत को ध्यान में रखते हुए हर दिन सुबह 5 बजे चलाने का कार्य निर्धारित कर सकता हूं ?

और इसके लिए भी TimerTaskबेहतर है या ScheduledExecutorService?

java  timertask  background-thread  scheduledexecutorservice 
— AKIWEB
स्रोत
इसके बजाय क्वार्ट्ज जैसी किसी चीज का इस्तेमाल करें।
— मिलीमोसे

जवाबों:

113

इसके साथ वर्तमान जावा एसई 8 रिलीज के साथ के रूप में के साथ उत्कृष्ट दिनांक समय एपीआई है java.timeगणना इस तरह उपयोग करने के बजाय और अधिक आसानी से किया जा सकता है java.util.Calendarऔरjava.util.Date ।

अब अपने उपयोग के मामले के साथ किसी कार्य को निर्धारित करने के लिए एक नमूना उदाहरण के रूप में:

ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/Los_Angeles"));
ZonedDateTime nextRun = now.withHour(5).withMinute(0).withSecond(0);
if(now.compareTo(nextRun) > 0)
    nextRun = nextRun.plusDays(1);

Duration duration = Duration.between(now, nextRun);
long initalDelay = duration.getSeconds();

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);            
scheduler.scheduleAtFixedRate(new MyRunnableTask(),
    initalDelay,
    TimeUnit.DAYS.toSeconds(1),
    TimeUnit.SECONDS);

initalDelayमें निष्पादन में देरी करने अनुसूचक पूछने के लिए की जाती है TimeUnit.SECONDS। यूनिट मिलिसकॉन्ड और नीचे के साथ समय का अंतर इस उपयोग के मामले के लिए नगण्य प्रतीत होता है। लेकिन आप अभी भी का उपयोग कर सकते duration.toMillis()हैं और TimeUnit.MILLISECONDSमिलीसेकेंड में समय-निर्धारण computaions से निपटने के लिए।

और भी TimerTask इस या ScheduledExecutorService के लिए बेहतर है?

NO: ScheduledExecutorService प्रतीत होता है की तुलना में बेहतर है TimerTask। StackOverflow आपके लिए पहले से ही एक उत्तर है ।

@ IPaddyD से,

यदि आपके पास सही स्थानीय समय पर चलने की इच्छा है, तब भी आपके पास यह समस्या है कि आप इसे वर्ष में दो बार पुनः आरंभ करने की आवश्यकता है। जब तक आप पूरे साल एक ही यूटीसी समय के साथ खुश नहीं होते हैं, शेड्यूल नहीं किया जाएगा।

जैसा कि यह सच है और @PaddyD ने पहले ही वर्कअराउंड (+1 उसे) दे दिया है, मैं Java8 डेट टाइम API के साथ एक वर्किंग उदाहरण प्रदान कर रहा हूं ScheduledExecutorService। डेमन धागे का उपयोग करना खतरनाक है 

class MyTaskExecutor
{
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
    MyTask myTask;
    volatile boolean isStopIssued;

    public MyTaskExecutor(MyTask myTask$) 
    {
        myTask = myTask$;

    }

    public void startExecutionAt(int targetHour, int targetMin, int targetSec)
    {
        Runnable taskWrapper = new Runnable(){

            @Override
            public void run() 
            {
                myTask.execute();
                startExecutionAt(targetHour, targetMin, targetSec);
            }

        };
        long delay = computeNextDelay(targetHour, targetMin, targetSec);
        executorService.schedule(taskWrapper, delay, TimeUnit.SECONDS);
    }

    private long computeNextDelay(int targetHour, int targetMin, int targetSec) 
    {
        LocalDateTime localNow = LocalDateTime.now();
        ZoneId currentZone = ZoneId.systemDefault();
        ZonedDateTime zonedNow = ZonedDateTime.of(localNow, currentZone);
        ZonedDateTime zonedNextTarget = zonedNow.withHour(targetHour).withMinute(targetMin).withSecond(targetSec);
        if(zonedNow.compareTo(zonedNextTarget) > 0)
            zonedNextTarget = zonedNextTarget.plusDays(1);

        Duration duration = Duration.between(zonedNow, zonedNextTarget);
        return duration.getSeconds();
    }

    public void stop()
    {
        executorService.shutdown();
        try {
            executorService.awaitTermination(1, TimeUnit.DAYS);
        } catch (InterruptedException ex) {
            Logger.getLogger(MyTaskExecutor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

ध्यान दें:

  • MyTask फ़ंक्शन के साथ एक इंटरफ़ेस है execute ।
  • रोकते समय ScheduledExecutorService, हमेशा इसे awaitTerminationलागू करने के बाद उपयोग करें shutdown: हमेशा एक संभावना है कि आपका कार्य अटक गया है / गतिरोध है और उपयोगकर्ता हमेशा के लिए इंतजार करेगा।

कैलेन्डर के साथ मैंने जो पिछले उदाहरण दिया, वह सिर्फ एक विचार था जिसका मैंने उल्लेख किया था, मैंने सटीक समय गणना और डेलाइट बचत के मुद्दों से बचा था। @PaddyD की शिकायत के अनुसार समाधान को अपडेट किया

— साधू
स्रोत
सुझाव के लिए धन्यवाद, क्या आप कृपया मुझे विस्तार से बता सकते हैं intDelayInHourकि सुबह 5 बजे मेरा काम कैसे चल रहा होगा?
— AKIWEB
ADate का उद्देश्य क्या है?
— जोस एंडियास
लेकिन अगर आप इसे HH: mm पर शुरू करते हैं तो टास्क को 05: mm पर चलाया जाएगा। यह ओपी के अनुरोध के अनुसार दिन के समय की बचत का भी हिसाब नहीं रखता है। ठीक है अगर आप इसे घंटे के तुरंत बाद शुरू करते हैं, या यदि आप 5 और 6 के बीच किसी भी समय खुश हैं, या अगर आप घड़ियों को बदलने के बाद एक वर्ष में दो बार रात के मध्य में आवेदन को फिर से शुरू करने से मन नहीं करते हैं तो मुझे लगता है ...
— धान्योदय
2
यदि आपके पास सही स्थानीय समय पर चलने की इच्छा है, तो भी आपके पास यह समस्या है कि आप इसे वर्ष में दो बार पुनः आरंभ करने की आवश्यकता है। scheduleAtFixedRateइसे तब तक नहीं काटेंगे जब तक आप पूरे साल एक ही यूटीसी समय से खुश न हों।
— धान का तेल
3
निम्न उदाहरण (दूसरा) ट्रिगर n बार या दूसरी पास होने तक क्यों चलता है? क्या हर दिन एक बार कार्य को गति देने के लिए कोड नहीं था?
— krizajb
25

जावा 8 में:

scheduler = Executors.newScheduledThreadPool(1);

//Change here for the hour you want ----------------------------------.at()       
Long midnight=LocalDateTime.now().until(LocalDate.now().plusDays(1).atStartOfDay(), ChronoUnit.MINUTES);
scheduler.scheduleAtFixedRate(this, midnight, 1440, TimeUnit.MINUTES);
— विजेता
स्रोत
14
पठनीयता के लिए मैं TimeUnit.DAYS.toMinutes(1)"मैजिक नंबर" 1440 के बजाय सुझाव
— दूंगा
धन्यवाद, विक्टर। इस तरह से मुझे वर्ष में दो बार पुनरारंभ करने की आवश्यकता है अगर मैं चाहता हूं कि यह सही स्थानीय समय पर चले?
— invzbl3
स्थानीय समय में परिवर्तन होने पर, निर्धारित दर में परिवर्तन नहीं होना चाहिए, निर्मित होने के बाद, यह दर के बारे में हो जाता है।
— विक्टर
यह कैसे 23:59:59 पर मेरे काम को ट्रिगर करता है?
— krizajb
पठनीयता के लिए मैं 1440 या TimeUnit.DAYS.toMinutes (1) के बजाय 1 का सुझाव दूंगा और फिर टाइम यूनिट TimeUnit.DAYS का उपयोग करूंगा। ;-)
— केली डेनेही
7

यदि आपके पास जावा 8 का उपयोग करने में सक्षम होने की विलासिता नहीं है, तो निम्नलिखित में से आपको क्या करना चाहिए:

public class DailyRunnerDaemon
{
   private final Runnable dailyTask;
   private final int hour;
   private final int minute;
   private final int second;
   private final String runThreadName;

   public DailyRunnerDaemon(Calendar timeOfDay, Runnable dailyTask, String runThreadName)
   {
      this.dailyTask = dailyTask;
      this.hour = timeOfDay.get(Calendar.HOUR_OF_DAY);
      this.minute = timeOfDay.get(Calendar.MINUTE);
      this.second = timeOfDay.get(Calendar.SECOND);
      this.runThreadName = runThreadName;
   }

   public void start()
   {
      startTimer();
   }

   private void startTimer();
   {
      new Timer(runThreadName, true).schedule(new TimerTask()
      {
         @Override
         public void run()
         {
            dailyTask.run();
            startTimer();
         }
      }, getNextRunTime());
   }


   private Date getNextRunTime()
   {
      Calendar startTime = Calendar.getInstance();
      Calendar now = Calendar.getInstance();
      startTime.set(Calendar.HOUR_OF_DAY, hour);
      startTime.set(Calendar.MINUTE, minute);
      startTime.set(Calendar.SECOND, second);
      startTime.set(Calendar.MILLISECOND, 0);

      if(startTime.before(now) || startTime.equals(now))
      {
         startTime.add(Calendar.DATE, 1);
      }

      return startTime.getTime();
   }
}

इसके लिए किसी बाहरी परिवाद की आवश्यकता नहीं है, और दिन के उजाले की बचत के लिए जिम्मेदार होगा। बस दिन के समय में आप एक Calendarवस्तु के रूप में कार्य चलाना चाहते हैं , और एक के रूप में कार्य Runnable। उदाहरण के लिए:

Calendar timeOfDay = Calendar.getInstance();
timeOfDay.set(Calendar.HOUR_OF_DAY, 5);
timeOfDay.set(Calendar.MINUTE, 0);
timeOfDay.set(Calendar.SECOND, 0);

new DailyRunnerDaemon(timeOfDay, new Runnable()
{
   @Override
   public void run()
   {
      try
      {
        // call whatever your daily task is here
        doHousekeeping();
      }
      catch(Exception e)
      {
        logger.error("An error occurred performing daily housekeeping", e);
      }
   }
}, "daily-housekeeping");

नायब टाइमर कार्य एक डेमन थ्रेड में चलता है जो किसी भी IO को करने के लिए अनुशंसित नहीं है। यदि आपको उपयोगकर्ता थ्रेड का उपयोग करने की आवश्यकता है, तो आपको एक और तरीका जोड़ना होगा जो टाइमर को रद्द कर देता है।

यदि आपको एक का उपयोग करना है ScheduledExecutorService, तो बस startTimerविधि को निम्नलिखित में बदलें :

private void startTimer()
{
   Executors.newSingleThreadExecutor().schedule(new Runnable()
   {
      Thread.currentThread().setName(runThreadName);
      dailyTask.run();
      startTimer();
   }, getNextRunTime().getTime() - System.currentTimeMillis(),
   TimeUnit.MILLISECONDS);
}

मैं व्यवहार के बारे में निश्चित नहीं हूं, लेकिन आपको एक स्टॉप विधि की आवश्यकता हो सकती है जो कॉल करती है shutdownNow यदि आप ScheduledExecutorServiceमार्ग से नीचे जाते हैं , अन्यथा जब आप इसे रोकने का प्रयास करते हैं तो आपका एप्लिकेशन हैंग हो सकता है।

— PaddyD
स्रोत
मै तुम्हारा मतलब समझ गया। +1 और धन्यवाद। हालांकि, यह बेहतर है अगर हम डेमन थ्रेड (यानी, new Timer(runThreadName, true)) का उपयोग नहीं करते हैं ।
— ऋषि
@ कोई चिंता नहीं। यदि आप कोई IO नहीं कर रहे हैं तो डेमन थ्रेड ठीक है। मैंने इसके लिए जो उपयोग मामला लिखा था, वह कुछ साधारण हाउसकीपिंग कार्यों को करने के लिए कुछ धागे को किक करने के लिए एक साधारण आग-और-भूल वर्ग था। मुझे लगता है कि यदि आप डेटाबेस प्रदर्शन कर रहे हैं टाइमर कार्य थ्रेड में ओपी के अनुरोध के रूप में संकेत हो सकता है, तो आपको डेमॉन का उपयोग नहीं करना चाहिए और किसी प्रकार की रोक विधि की आवश्यकता होगी जिसे समाप्त करने के लिए आपको अपने आवेदन को सक्षम करने के लिए कॉल करना होगा। stackoverflow.com/questions/7067578/…
— PaddyD
@PaddyD पिछले भाग था यानी शेड्यूल्ड एग्ज़िक्युरसेवर सही का उपयोग करने वाला ??? अनाम वर्ग जिस तरह से बनाया गया है वह सही वाक्यविन्यास नहीं दिखता है। इसके अलावा newSingleThreadExecutor () होगा अनुसूची विधि सही ??
— फ्रीज फ्रांसिस
6

क्या आपने क्वार्ट्ज शेड्यूलर जैसी किसी चीज का उपयोग करने पर विचार किया है ? इस लाइब्रेरी में अभिव्यक्ति की तरह क्रोन का उपयोग करके हर दिन एक निर्धारित अवधि में चलने के लिए शेड्यूलिंग कार्यों के लिए एक तंत्र है (एक नज़र डालें CronScheduleBuilder)।

कुछ उदाहरण कोड (परीक्षण नहीं):

public class GetDatabaseJob implements InterruptableJob
{
    public void execute(JobExecutionContext arg0) throws JobExecutionException
    {
        getFromDatabase();
    }
}

public class Example
{
    public static void main(String[] args)
    {
        JobDetails job = JobBuilder.newJob(GetDatabaseJob.class);

        // Schedule to run at 5 AM every day
        ScheduleBuilder scheduleBuilder = 
                CronScheduleBuilder.cronSchedule("0 0 5 * * ?");
        Trigger trigger = TriggerBuilder.newTrigger().
                withSchedule(scheduleBuilder).build();

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.scheduleJob(job, trigger);

        scheduler.start();
    }
}

थोड़ा और काम करने की जरूरत है, और आपको अपने कार्य निष्पादन कोड को फिर से लिखने की आवश्यकता हो सकती है, लेकिन इससे आपको अधिक नियंत्रण देना चाहिए कि आप किस तरह से नौकरी चलाना चाहते हैं। इसके अलावा शेड्यूल में बदलाव करना आसान होगा जो आपको चाहिए।

— lmika
स्रोत
5

Java8:
शीर्ष उत्तर से मेरा उत्थान संस्करण:

  1. वेब थ्रेड सर्वर के निष्क्रिय होने के कारण वेब साइट सर्वर बंद होने की स्थिति में नहीं है
  2. पुनरावृत्ति के बिना
  3. अपने कस्टम स्थानीय समय के साथ कार्य को चलाएं, मेरे मामले में, यह बेलारूस, मिन्स्क है


/**
 * Execute {@link AppWork} once per day.
 * <p>
 * Created by aalexeenka on 29.12.2016.
 */
public class OncePerDayAppWorkExecutor {

    private static final Logger LOG = AppLoggerFactory.getScheduleLog(OncePerDayAppWorkExecutor.class);

    private ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    private final String name;
    private final AppWork appWork;

    private final int targetHour;
    private final int targetMin;
    private final int targetSec;

    private volatile boolean isBusy = false;
    private volatile ScheduledFuture<?> scheduledTask = null;

    private AtomicInteger completedTasks = new AtomicInteger(0);

    public OncePerDayAppWorkExecutor(
            String name,
            AppWork appWork,
            int targetHour,
            int targetMin,
            int targetSec
    ) {
        this.name = "Executor [" + name + "]";
        this.appWork = appWork;

        this.targetHour = targetHour;
        this.targetMin = targetMin;
        this.targetSec = targetSec;
    }

    public void start() {
        scheduleNextTask(doTaskWork());
    }

    private Runnable doTaskWork() {
        return () -> {
            LOG.info(name + " [" + completedTasks.get() + "] start: " + minskDateTime());
            try {
                isBusy = true;
                appWork.doWork();
                LOG.info(name + " finish work in " + minskDateTime());
            } catch (Exception ex) {
                LOG.error(name + " throw exception in " + minskDateTime(), ex);
            } finally {
                isBusy = false;
            }
            scheduleNextTask(doTaskWork());
            LOG.info(name + " [" + completedTasks.get() + "] finish: " + minskDateTime());
            LOG.info(name + " completed tasks: " + completedTasks.incrementAndGet());
        };
    }

    private void scheduleNextTask(Runnable task) {
        LOG.info(name + " make schedule in " + minskDateTime());
        long delay = computeNextDelay(targetHour, targetMin, targetSec);
        LOG.info(name + " has delay in " + delay);
        scheduledTask = executorService.schedule(task, delay, TimeUnit.SECONDS);
    }

    private static long computeNextDelay(int targetHour, int targetMin, int targetSec) {
        ZonedDateTime zonedNow = minskDateTime();
        ZonedDateTime zonedNextTarget = zonedNow.withHour(targetHour).withMinute(targetMin).withSecond(targetSec).withNano(0);

        if (zonedNow.compareTo(zonedNextTarget) > 0) {
            zonedNextTarget = zonedNextTarget.plusDays(1);
        }

        Duration duration = Duration.between(zonedNow, zonedNextTarget);
        return duration.getSeconds();
    }

    public static ZonedDateTime minskDateTime() {
        return ZonedDateTime.now(ZoneId.of("Europe/Minsk"));
    }

    public void stop() {
        LOG.info(name + " is stopping.");
        if (scheduledTask != null) {
            scheduledTask.cancel(false);
        }
        executorService.shutdown();
        LOG.info(name + " stopped.");
        try {
            LOG.info(name + " awaitTermination, start: isBusy [ " + isBusy + "]");
            // wait one minute to termination if busy
            if (isBusy) {
                executorService.awaitTermination(1, TimeUnit.MINUTES);
            }
        } catch (InterruptedException ex) {
            LOG.error(name + " awaitTermination exception", ex);
        } finally {
            LOG.info(name + " awaitTermination, finish");
        }
    }

}
— एलेक्सी अलेक्जेंका
स्रोत
1
मेरी भी ऐसी ही आवश्यकता है। मुझे दिए गए समय पर एक दिन के लिए कार्य निर्धारित करना है। एक बार निर्धारित कार्य पूरा हो जाने पर, निर्धारित समय पर अगले दिन के लिए कार्य निर्धारित करें। यह जारी रखना चाहिए। मेरा सवाल यह है कि यह पता लगाना है कि निर्धारित कार्य पूरा हो गया है या नहीं। एक बार जब मुझे पता है कि शेड्यूल किया गया टास्क पूरा हो गया है, तो ही मैं अगले दिन के लिए शेड्यूल कर सकता हूं।
— अमिताभ
2

मुझे भी ऐसी ही समस्या का समाधान करना पड़ा था। मुझे उन कार्यों का गुच्छा निर्धारित करना था, जिनका उपयोग करते हुए एक दिन के दौरान निष्पादित किया जाना चाहिए ScheduledExecutorService। यह 3:30 पूर्वाह्न से शुरू होने वाले एक कार्य द्वारा हल किया गया था जो अन्य सभी कार्यों को उनके वर्तमान समय के लिए अपेक्षाकृत निर्धारित करता है । और अगले दिन 3:30 पूर्वाह्न के लिए खुद को पुनर्निर्धारित किया।

इस परिदृश्य के साथ दिन के उजाले की बचत अब कोई मुद्दा नहीं है।

— user987339
स्रोत
2

आप एक साधारण तिथि पारे का उपयोग कर सकते हैं, यदि दिन का समय अब ​​से पहले है, तो कल शुरू करें:

  String timeToStart = "12:17:30";
  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss");
  SimpleDateFormat formatOnlyDay = new SimpleDateFormat("yyyy-MM-dd");
  Date now = new Date();
  Date dateToStart = format.parse(formatOnlyDay.format(now) + " at " + timeToStart);
  long diff = dateToStart.getTime() - now.getTime();
  if (diff < 0) {
    // tomorrow
    Date tomorrow = new Date();
    Calendar c = Calendar.getInstance();
    c.setTime(tomorrow);
    c.add(Calendar.DATE, 1);
    tomorrow = c.getTime();
    dateToStart = format.parse(formatOnlyDay.format(tomorrow) + " at " + timeToStart);
    diff = dateToStart.getTime() - now.getTime();
  }

  ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);            
  scheduler.scheduleAtFixedRate(new MyRunnableTask(), TimeUnit.MILLISECONDS.toSeconds(diff) ,
                                  24*60*60, TimeUnit.SECONDS);
— ल्यूक चेवेलियर
स्रोत
1

बस विक्टर के जवाब पर जोड़ने के लिए ।

मैं देखने के लिए एक चेक जोड़ने की सिफारिश करूंगा, अगर चर (उसके मामले में लंबा midnight) से अधिक है 1440। यदि ऐसा है, तो मैं इसे छोड़ .plusDays(1)दूंगा, अन्यथा कार्य केवल परसों चलेंगे।

मैंने इसे इस तरह किया:

Long time;

final Long tempTime = LocalDateTime.now().until(LocalDate.now().plusDays(1).atTime(7, 0), ChronoUnit.MINUTES);
if (tempTime > 1440) {
    time = LocalDateTime.now().until(LocalDate.now().atTime(7, 0), ChronoUnit.MINUTES);
} else {
    time = tempTime;
}
— Niby
स्रोत
यदि आप इसका उपयोग सरल करते हैं तोtruncatedTo()
— मार्क जेरोनिमस
1

निम्नलिखित उदाहरण मेरे लिए काम करते हैं

public class DemoScheduler {

    public static void main(String[] args) {

        // Create a calendar instance
        Calendar calendar = Calendar.getInstance();

        // Set time of execution. Here, we have to run every day 4:20 PM; so,
        // setting all parameters.
        calendar.set(Calendar.HOUR, 8);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.AM_PM, Calendar.AM);

        Long currentTime = new Date().getTime();

        // Check if current time is greater than our calendar's time. If So,
        // then change date to one day plus. As the time already pass for
        // execution.
        if (calendar.getTime().getTime() < currentTime) {
            calendar.add(Calendar.DATE, 1);
        }

        // Calendar is scheduled for future; so, it's time is higher than
        // current time.
        long startScheduler = calendar.getTime().getTime() - currentTime;

        // Setting stop scheduler at 4:21 PM. Over here, we are using current
        // calendar's object; so, date and AM_PM is not needed to set
        calendar.set(Calendar.HOUR, 5);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.AM_PM, Calendar.PM);

        // Calculation stop scheduler
        long stopScheduler = calendar.getTime().getTime() - currentTime;

        // Executor is Runnable. The code which you want to run periodically.
        Runnable task = new Runnable() {

            @Override
            public void run() {

                System.out.println("test");
            }
        };

        // Get an instance of scheduler
        final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        // execute scheduler at fixed time.
        scheduler.scheduleAtFixedRate(task, startScheduler, stopScheduler, MILLISECONDS);
    }
}

संदर्भ: https://chynten.wordpress.com/2016/06/03/java-scheduler-to-run-every-day-on-specific-time/

— शैक एलियास
स्रोत
1

आप अपने कार्य को हर दिन विशेष समय निर्धारित करने के लिए कक्षा के नीचे का उपयोग कर सकते हैं 

package interfaces;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class CronDemo implements Runnable{

    public static void main(String[] args) {

        Long delayTime;

        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        final Long initialDelay = LocalDateTime.now().until(LocalDate.now().plusDays(1).atTime(12, 30), ChronoUnit.MINUTES);

        if (initialDelay > TimeUnit.DAYS.toMinutes(1)) {
            delayTime = LocalDateTime.now().until(LocalDate.now().atTime(12, 30), ChronoUnit.MINUTES);
        } else {
            delayTime = initialDelay;
        }

        scheduler.scheduleAtFixedRate(new CronDemo(), delayTime, TimeUnit.DAYS.toMinutes(1), TimeUnit.MINUTES);

    }

    @Override
    public void run() {
        System.out.println("I am your job executin at:" + new Date());
    }
}
— अमोल सूर्यवंशी
स्रोत
1
कृपया पुराने का उपयोग न करें Dateऔर TimeUnit2019 में
— मार्क जेरोनिमस
0

क्या होगा यदि आपका सर्वर 4:59 बजे नीचे चला जाता है और 5:01 बजे वापस आता है? मुझे लगता है कि यह सिर्फ रन को छोड़ देगा। मैं क्वार्ट्ज की तरह लगातार शेड्यूलर की सिफारिश करूंगा, जो अपने शेड्यूल डेटा को कहीं स्टोर करेगा। फिर यह देखेगा कि यह रन अभी तक नहीं किया गया है और वह 5:01 बजे करेगा।

— सैम
स्रोत
0

एक स्थिति को जटिल क्यों करें यदि आप इसे केवल लिख सकते हैं? (हाँ -> कम सामंजस्य, हार्डकोड -> लेकिन यह एक उदाहरण है और दुर्भाग्य से अनिवार्य तरीका है)। अतिरिक्त जानकारी के लिए नीचे कोड उदाहरण पढ़ें;)

package timer.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.concurrent.*;

public class TestKitTimerWithExecuterService {

    private static final Logger log = LoggerFactory.getLogger(TestKitTimerWithExecuterService.class);

    private static final ScheduledExecutorService executorService 
= Executors.newSingleThreadScheduledExecutor();// equal to => newScheduledThreadPool(1)/ Executor service with one Thread

    private static ScheduledFuture<?> future; // why? because scheduleAtFixedRate will return you it and you can act how you like ;)



    public static void main(String args[]){

        log.info("main thread start");

        Runnable task = () -> log.info("******** Task running ********");

        LocalDateTime now = LocalDateTime.now();

        LocalDateTime whenToStart = LocalDate.now().atTime(20, 11); // hour, minute

        Duration duration = Duration.between(now, whenToStart);

        log.info("WhenToStart : {}, Now : {}, Duration/difference in second : {}",whenToStart, now, duration.getSeconds());

        future = executorService.scheduleAtFixedRate(task
                , duration.getSeconds()    //  difference in second - when to start a job
                ,2                         // period
                , TimeUnit.SECONDS);

        try {
            TimeUnit.MINUTES.sleep(2);  // DanDig imitation of reality
            cancelExecutor();    // after canceling Executor it will never run your job again
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("main thread end");
    }




    public static void cancelExecutor(){

        future.cancel(true);
        executorService.shutdown();

        log.info("Executor service goes to shut down");
    }

}
— मूसा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.