ScheduledExecutorServiceを使用して、特定の時間に特定のタスクを毎日実行するにはどうすればよいですか?


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ですか?


代わりにQuartzのようなものを使用してください。
ミリムース2013

回答:


113

現在のjavaSE 8リリースと同様に、java.timeこの種の計算を備えた優れた日時APIは、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を利用することはできます。

また、TimerTaskはこれまたはScheduledExecutorServiceに適していますか?

いいえ: ScheduledExecutorService一見より良いですTimerTaskStackOverflowにはすでに答えがあります

@PaddyDから、

適切な現地時間で実行したい場合は、これを年に2回再起動する必要があるという問題がまだあります。年間を通して同じUTC時間に満足しない限り、scheduleAtFixedRateはそれをカットしません。

それは真実であり、@ 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です。
  • 停止中ScheduledExecutorServiceawaitTermination、呼び出しshutdownた後に必ず使用してください。タスクがスタック/デッドロックする可能性が常にあり、ユーザーは永遠に待機します。

Calenderで示した前の例は、私が言及した単なるアイデアであり、正確な時間計算と夏時間の問題を回避しました。@PaddyDの苦情に従ってソリューションを更新しました


提案をありがとうございintDelayInHourます。午前5時にタスクを実行することの意味を詳しく説明してください。
AKIWEB 2013

aDateの目的は何ですか?
ホセアンディアス2014

しかし、これをHH:mmで開始すると、タスクは午前5時ではなく05:mmで実行されますか?また、OPが要求した夏時間も考慮されていません。時間の直後に開始する場合、5〜6の時間に満足している場合、または時計が変更された後、年に2回深夜にアプリケーションを再起動してもかまわない場合は、OKだと思います。 ...
PaddyD 2014年

2
適切な現地時間で実行したい場合は、これを年に2回再起動する必要があるという問題がまだあります。scheduleAtFixedRate一年中同じUTC時間に満足しない限り、それを削減することはありません。
paddyD 2014年

3
次の例(2番目)のトリガーがn回、または2番目が経過するまで実行されるのはなぜですか?コードは、タスクを1日1回トリガーすることを想定していませんでしたか?
krizajb 2018

25

Java 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の代わりに
philonous

ありがとう、ビクター。このように、適切な現地時間で実行したい場合は、年に2回再起動する必要がありますか?
invzbl3 2018

現地時間が変わっても固定金利は変わらないはずで、作成後はほぼ金利になります。
ビクター

なぜこれが23:59:59に私のタスクをトリガーするのですか?
krizajb 2018

読みやすくするために、1440またはTimeUnit.DAYS.toMinutes(1)の代わりに1を提案してから、時間単位TimeUnit.DAYSを使用します。;-)
Kelly Denehy 2018年

7

Java 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の実行には推奨されないデーモンスレッドで実行されます。ユーザースレッドを使用する必要がある場合は、タイマーをキャンセルする別のメソッドを追加する必要があります。

を使用する必要がある場合はScheduledExecutorServicestartTimerメソッドを次のように変更するだけです。

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

私は確かに行動のないですが、あなたは呼び出すstopメソッドが必要な場合がありshutdownNowますがダウンした場合ScheduledExecutorService、あなたはそれを停止しようとすると、そうでない場合は、アプリケーションがハングすることがあり、ルートを。


私はあなたのポイントを得ました。+1していただきありがとうございます。ただし、デーモンスレッド(つまりnew Timer(runThreadName, true))を使用しない方がよいでしょう。
セージ

@Sage心配ありません。IOを実行していない場合は、デーモンスレッドで問題ありません。私がこれを書いたユースケースは、いくつかのスレッドを開始して毎日のハウスキーピングタスクを実行するための単純なファイアアンドフォーゲットクラスでした。OPの要求が示すように、タイマータスクスレッドでデータベース読み取りを実行している場合は、デーモンを使用しないでください。アプリケーションを終了できるようにするために呼び出す必要がある、ある種の停止メソッドが必要になります。stackoverflow.com/questions/7067578/...
PaddyD

@PaddyDは最後の部分、つまりScheduledExecutorSeriveを使用した部分でしたか?匿名クラスの作成方法は、構文的には正しくありません。また、newSingleThreadExecutor()にはスケジュールメソッドがありませんか?
FReeze FRancis 2017

6

Quartz Schedulerのようなものの使用を検討しましたか?このライブラリには、cronのような式を使用して毎日設定された時間に実行されるタスクをスケジュールするためのメカニズムがあります(を見てください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();
    }
}

事前にもう少し作業が必要で、ジョブ実行コードを書き直す必要があるかもしれませんが、ジョブの実行方法をより細かく制御できるはずです。また、必要に応じてスケジュールを変更する方が簡単です。


5

Java8:
トップアンサーからの私のアップグレードバージョン:

  1. アイドルスレッドのスレッドプールが原因でWebアプリケーションサーバーが停止したくない状況を修正しました
  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
同様の要件があります。ある時間に1日のタスクをスケジュールする必要があります。スケジュールされたタスクが完了したら、指定された時間に翌日のタスクをスケジュールします。これは継続する必要があります。私の質問は、スケジュールされたタスクが完了したかどうかを確認する方法です。スケジュールされたタスクが完了したことがわかったら、次の日にスケジュールできるのは私だけです。
amitwdh

2

私も同様の問題を抱えていました。を使用して、1日の間に実行する必要のある一連のタスクをスケジュールする必要がありましたScheduledExecutorService。これは、午前3時30分に開始する1つのタスクによって、現在の時刻に関連して他のすべてのタスクをスケジュールすることで解決されまし。そして、翌日の午前3時30分に自分のスケジュールを変更します。

このシナリオでは、夏時間はもはや問題ではありません。


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

ただ、上に追加するにはビクターの答え

変数(彼の場合はlong 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;
}

利用すれば簡単になりますtruncatedTo()
MarkJeronimus20年

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
時代遅れ使用しないでくださいDateTimeUnit2019年を
マーク・Jeronimus

0

サーバーが4:59 AMにダウンし、5:01AMに戻った場合はどうなりますか?実行をスキップするだけだと思います。スケジュールデータをどこかに保存するQuartzのような永続的なスケジューラーをお勧めします。次に、この実行がまだ実行されていないことがわかり、午前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");
    }

}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.