Executing some code after a specific amount of time

Question

I need to execute an action after a specific amount of time (for example 30 minutes after the app started up, if the app is still up).

What are my options and will it necessary means there's going to be one thread "lost" waiting for the 30 minutes to pass by?

Ideally, at program startup, I'd like to do something like the following (simplified on purpose) and then don't have to think about it anymore:

   doIfStillUp( 30, new Runnable() {
       ....    
   }); 

So how should I go about implementing doIfStillUp(...)?

Should I use a TimerTask? The Executor framework?

Most importantly (it's for understanding purpose): does this mean there's going to be one thread lost idling for basically nothing during 30 minutes?

If there's going to be one thread "doing nothing", is this an issue? What if there are 10 000 threads (I'm being facetious here) "doing nothing"?

Note that I'm trying to understand the "big picture", not to solve a particular problem.

Answer 1

The Executor framework is a reasonable choice.

There's a schedule method that just takes a runnable and a delay time.

schedule(Runnable command,
         long delay,
         TimeUnit unit)

That's pretty straightforward. There won't necessarily be a thread blocked waiting on your task. You could use a ScheduledThreadPoolExecutor, as linked above that keeps X threads ready to run scheduled tasks.

You can imagine a data structure that holds the time at which a task should be run. A single thread can watch or set up these delays and can potentially watch thousands of them in a single thread. When the first time expires it'll run the task. Potentially using its own thread, potentially using 1 of X in the thread pool. When a new task is added or an existing task is finished it'll wait for the earliest time to arrive and then start the whole process again.

Answer 2

You should use a Timer. Its javadoc answers all your questions.

One thread is used for every timer, but the timer executes several tasks, sequentially. The timer tasks should be very short. If they aren't, consider using several timers.

Of course, the timer thread will be idle if it doesn't have any task to execute. An idle thread doesn't consume anything (or nearly anything), so I wouldn't worry about it. Anyway, you don't have many choices. 10000 threads doing nothing would of course be an issue, but that would mean that you instantiated one timer per task, which is wrong.