How To Call a Method on Specific Time in Java?

In the example above, we create an instance of Timer and define a TimerTask with the run() method overridden to contain the code you want to execute at a specific time. We then specify the delay (in milliseconds) after which the task should be executed. Finally, we schedule the task using timer.schedule(task, delay).

When the specified time is reached, the run() method of the TimerTask will be invoked, which will, in turn, call your desired method (myMethod() in this example).

Note that java.util.Timer is a simple and straightforward way to schedule tasks, but if you require more advanced scheduling capabilities or better thread management, you might consider using java.util.concurrent.ScheduledExecutorService instead.

Apologies for the confusion in my previous response. The java.util.Timer and java.util.TimerTask approach is indeed a valid way to schedule tasks at specific times in Java. Here's an updated example using Timer and TimerTask:

import java.util.Timer;
import java.util.TimerTask;

public class MethodScheduler {
    public static void main(String[] args) {
        Timer timer = new Timer();
        
        // Create a TimerTask to define the task you want to execute
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                // Call your method here
                myMethod();
            }
        };
        
        // Define the time at which you want to execute the task
        // In this example, the task will run at 9:00 AM (24-hour format)
        int hour = 9;
        int minute = 0;
        int second = 0;
        
        // Get the current time
        long currentTimeMillis = System.currentTimeMillis();
        
        // Calculate the delay until the specified time
        long delay = calculateDelay(hour, minute, second, currentTimeMillis);
        
        // Schedule the task to run once at the specified time
        timer.schedule(task, delay);
    }
    
    public static void myMethod() {
        // Implementation of your method
        System.out.println("Method called at specific time!");
    }
    
    private static long calculateDelay(int hour, int minute, int second, long currentTimeMillis) {
        // Get the current time as a Calendar instance
        java.util.Calendar calendar = java.util.Calendar.getInstance();
        calendar.setTimeInMillis(currentTimeMillis);
        
        // Set the desired time for the task
        calendar.set(java.util.Calendar.HOUR_OF_DAY, hour);
        calendar.set(java.util.Calendar.MINUTE, minute);
        calendar.set(java.util.Calendar.SECOND, second);
        calendar.set(java.util.Calendar.MILLISECOND, 0);
        
        // Calculate the delay until the desired time
        long desiredTimeMillis = calendar.getTimeInMillis();
        long delay = desiredTimeMillis - currentTimeMillis;
        
        // Adjust the delay if the desired time has already passed for today
        if (delay < 0) {
            delay += 24 * 60 * 60 * 1000; // Add 24 hours (in milliseconds)
        }
        
        return delay;
    }
}

In this updated example, we create a Timer instance and define a TimerTask as before. However, instead of specifying a delay in milliseconds, we calculate the delay until the desired time using the calculateDelay() method.

The calculateDelay() method takes the desired hour, minute, second, and the current time as parameters. It creates a Calendar instance, sets the desired time, and calculates the difference between the desired time and the current time. If the desired time has already passed for the current day, it adjusts the delay by adding 24 hours.

The task is then scheduled to run once at the specified time using timer.schedule(task, delay).

Once the specified time is reached, the run() method of the TimerTask will be executed, which calls your desired method (myMethod() in this example).

The Timer and TimerTask approach provides a simple way to schedule tasks at specific times, but keep in mind that it uses a single background thread for task execution. If you require more advanced scheduling capabilities or better thread management, consider using the ScheduledExecutorService from the java.util.concurrent package.