I have tried to delay - or put to sleep - my Java program, but an error occurs.
I'm unable to use Thread.sleep(x) or wait(). The same error message appears:
unreported exception java.lang.InterruptedException; must be caught or declared to be thrown.
Is there any step required before using the Thread.sleep() or wait() methods?
Use the following coding construct to handle exceptions
try {
Thread.sleep(1000);
} catch (InterruptedException ie) {
//Handle exception
}
Try this:
try{
Thread.sleep(100);
}catch(Exception e)
{
System.out.println("Exception caught");
}
public static void main(String[] args) throws InterruptedException {
//type code
short z=1000;
Thread.sleep(z);/*will provide 1 second delay. alter data type of z or value of z for longer delays required */
//type code
}
eg:-
class TypeCasting {
public static void main(String[] args) throws InterruptedException {
short f = 1;
int a = 123687889;
short b = 2;
long c = 4567;
long d=45;
short z=1000;
System.out.println("Value of a,b and c are\n" + a + "\n" + b + "\n" + c + "respectively");
c = a;
b = (short) c;
System.out.println("Typecasting...........");
Thread.sleep(z);
System.out.println("Value of B after Typecasting" + b);
System.out.println("Value of A is" + a);
}
}
Put your Thread.sleep in a try catch block
try {
//thread to sleep for the specified number of milliseconds
Thread.sleep(100);
} catch ( java.lang.InterruptedException ie) {
System.out.println(ie);
}
Use java.util.concurrent.TimeUnit:
TimeUnit.SECONDS.sleep(1);
Sleep for one second or
TimeUnit.MINUTES.sleep(1);
Sleep for a minute.
As this is a loop, this presents an inherent problem - drift. Every time you run code and then sleep you will be drifting a little bit from running, say, every second. If this is an issue then don't use sleep.
Further, sleep isn't very flexible when it comes to control.
For running a task every second or at a one second delay I would strongly recommend a [ScheduledExecutorService][1] and either [scheduleAtFixedRate][2] or [scheduleWithFixedDelay][3].
To run the method myTask every second (Java 8):
public static void main(String[] args) {
final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.scheduleAtFixedRate(App::myTask, 0, 1, TimeUnit.SECONDS);
}
private static void myTask() {
System.out.println("Running");
}
Alternatively, if you don't want to deal with threads, try this method:
public static void pause(int seconds){
Date start = new Date();
Date end = new Date();
while(end.getTime() - start.getTime() < seconds * 1000){
end = new Date();
}
}
It starts when you call it, and ends when the number of seconds have passed.
A simpler way to wait is to use System.currentTimeMillis(), which returns the number of milliseconds since midnight on January 1, 1970 UTC. For example, to wait 5 seconds:
public static void main(String[] args) {
//some code
long original = System.currentTimeMillis();
while (true) {
if (System.currentTimeMillis - original >= 5000) {
break;
}
}
//more code after waiting
}
This way, you don't have to muck about with threads and exceptions. Hope this helps!
Have a look at this excellent brief post on how to do this properly.
Essentially: catch the InterruptedException. Remember that you must add this catch-block. The post explains this a bit further.
When using Android (the only time when I use Java) I would recommend using a handler instead putting the thread to sleep.
final Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
Log.i(TAG, "I've waited for two hole seconds to show this!");
}
}, 2000);
Reference: http://developer.android.com/reference/android/os/Handler.html
Thread.sleep() is simple for the beginners and may be appropriate for unit tests and proofs of concept.
But please DO NOT use sleep() for production code. Eventually sleep() may bite you badly.
Best practice for multithreaded/multicore java applications to use the "thread wait" concept. Wait releases all the locks and monitors held by the thread, which allows other threads to acquire those monitors and proceed while your thread is sleeping peacefully.
Code below demonstrates that technique:
import java.util.concurrent.TimeUnit;
public class DelaySample {
public static void main(String[] args) {
DelayUtil d = new DelayUtil();
System.out.println("started:"+ new Date());
d.delay(500);
System.out.println("half second after:"+ new Date());
d.delay(1, TimeUnit.MINUTES);
System.out.println("1 minute after:"+ new Date());
}
}
DelayUtil implementation:
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class DelayUtil {
/**
* Delays the current thread execution.
* The thread loses ownership of any monitors.
* Quits immediately if the thread is interrupted
*
* @param durationInMillis the time duration in milliseconds
*/
public void delay(final long durationInMillis) {
delay(durationInMillis, TimeUnit.MILLISECONDS);
}
/**
* @param duration the time duration in the given {@code sourceUnit}
* @param unit
*/
public void delay(final long duration, final TimeUnit unit) {
long currentTime = System.currentTimeMillis();
long deadline = currentTime+unit.toMillis(duration);
ReentrantLock lock = new ReentrantLock();
Condition waitCondition = lock.newCondition();
while ((deadline-currentTime)>0) {
try {
lock.lockInterruptibly();
waitCondition.await(deadline-currentTime, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
} finally {
lock.unlock();
}
currentTime = System.currentTimeMillis();
}
}
}
As other users have said you should surround your call with a try{...} catch{...} block. But since Java 1.5 was released, there is TimeUnit class which do the same as Thread.sleep(millis) but is more convenient.
You can pick time unit for sleep operation.
try {
TimeUnit.NANOSECONDS.sleep(100);
TimeUnit.MICROSECONDS.sleep(100);
TimeUnit.MILLISECONDS.sleep(100);
TimeUnit.SECONDS.sleep(100);
TimeUnit.MINUTES.sleep(100);
TimeUnit.HOURS.sleep(100);
TimeUnit.DAYS.sleep(100);
} catch (InterruptedException e) {
//Handle exception
}
Also it has additional methods: TimeUnit Oracle Documentation
My ways to add delay to a Java program.
public void pause1(long sleeptime) {
try {
Thread.sleep(sleeptime);
} catch (InterruptedException ex) {
//ToCatchOrNot
}
}
public void pause2(long sleeptime) {
Object obj = new Object();
if (sleeptime > 0) {
synchronized (obj) {
try {
obj.wait(sleeptime);
} catch (InterruptedException ex) {
//ToCatchOrNot
}
}
}
}
public void pause3(long sleeptime) {
expectedtime = System.currentTimeMillis() + sleeptime;
while (System.currentTimeMillis() < expectedtime) {
//Empty Loop
}
}
This is for sequential delay but for Loop delays refer to Java Delay/Wait.
Source: Stackoverflow.com