Java run event at certain time in future

Question

I am designing a java web app using jersey in which i having a date time field, "future_time" in mysql db. I am also a having a status field in the same table set to pending. I want to update the status field to completed in db if the current time >= future_time. It is like I want to schedule a event.

Secondly if current_ time < future_time and if i updated the future_time value, i would i like to reschedule the previous event.

Currently, whenever i fetch status field i check if it is pending, if it is pending then i check if future_time<= current_time, if so then i update the status field in db to completed. But there is a problem in this. This will only update the status field when i fetch it. So if i fetch the status field after a long time(after future_time) , then it will be update at that instant, saving incorrect records in db.

Can anyone suggest me a better way to achieve this?

Answer 1

You can use ScheduledExecutorService for scheduling the tasks at specific interval of time, after some fixed delays or at some specific point in time.

You can create the ScheduledExecutorService like:

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();

And then use the service for scheduling the jobs like:

//scheduling at fixed time.
Future<String> resultFuture = executorService.schedule(new Callable<String>() {
    @Override
    public String call() throws Exception
    {
        //your code;
    }
}, 1, TimeUnit.SECONDS);

//scheduling at fixed intervals.
executorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run()
    {
        //your code
    }
}, 100, 450, TimeUnit.MILLISECONDS);

//scheduling at fixed delays.
executorService.scheduleWithFixedDelay(new Runnable() {
    @Override
    public void run()
    {
        //your code
    }
}, 100, 150, TimeUnit.MILLISECONDS);

You can also use Java Timer Utility to schedule the tasks for the future but Java specification says to prefer the ScheduledExecutorService. Below is a sample code for scheduling the jobs with Timer.

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


/**
 * An example for Java Timer Utility.
 *
 * @author Karan Khanna.
 */
public class TimerExample
{

    public static void scheduleTaskForFuture(final Date date)
    {
        Timer timer = new Timer("Timer");
        TimerTask task = new TimerTask()
        {
            public void run()
            {

                System.out.println(
                    String
                        .format("Task performed on: %s and Thread's name: %s", date, Thread.currentThread().getName()));

                timer.cancel();
            }
        };
        timer.schedule(task, date);
    }



    public static void main(final String[] args)
    {
        Calendar calendar = new GregorianCalendar();
        calendar.add(Calendar.MINUTE, 1);
        TimerExample.scheduleTaskForFuture(calendar.getTime());
    }
}

You can explore the utility more to schedule repeated tasks. Also, don't forget to cancel the task once the required job is done.

You can also try other frameworks like Quartz and Spring scheduling for the purpose.

Answer 2

Calculate elapsed time until deadline

With JDBC 4.2 and later, retrieve the date-time using the modern java.time classes.

OffsetDateTime odt = myResultSet.getObject( … , OffsetDateTime.class );  // Likely to be a UTC value.

Get current moment.

OffsetDateTime now = OffsetDateTime.now( ZoneOffset.UTC ) ;

Calculate elapsed time.

Duration d = Duration.between( now , odt ) ;

Schedule event

Use the modern Executor framework rather than the legacy Timer class. This is especially true in a Servlet or Jakarta.ee (Java EE) environment.

Define your executor, specifically a ScheduledExecutorService. We need only a single thread for this task.

ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor()

Ask that executor to wait a certain amount of time, then run your code to check the status in the database.

myExecutorService.schedule(           // Tell the executor what you want to run, and when you want it run on your behalf in a background thread.
    new Runnable() { … } ,            // Define task to be executed as a `Runnable`.
    d.toSeconds() ,                   // Amount of time to wait until execution. Use self-documenting code rather than a “magic number” such as `86400000`. 
    TimeUnit.SECONDS                  // Specify the granularity of time used in previous pair of arguments.
)                                     // Returns a `ScheduledFuture` which you may want to cache.

Optionally, you can capture the ScheduledFuture returned by this schedule statement. You can then monitor completion status.

In your Runnable, retrieve the current status record from your database. If warranted, schedule another execution, re-calculating time to wait using a new current moment.

Servlet web container

For a Servlet web container such as Tomcat or Jetty without the full Jakarta.ee stack, the above discussion applies.

Furthermore, you will want to write a class that implements the ServletContextListener interface where you can set-up and tear-down your executor service. You need to gracefully tear-down the executor service so that its background thread does not continue merrily on its way long after your web app has shutdown.

Jakarta EE

If in a full-blown Jakarta.ee stack such as Glassfish, this work is much easier.

The executor service seen above can be automated, with set-up and tear-down performed on your behalf. Use the concurrency utilities defined in JSR 236: Concurrency Utilities for JavaTM EE. This has been covered many times, so search Stack Overflow for more info.

---

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8, Java SE 9, Java SE 10, Java SE 11, and later - Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Most of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
• Android
  • Later versions of Android bundle implementations of the java.time classes.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.