Developer.com content material and product suggestions are editorially unbiased. We could earn money if you click on on hyperlinks to our companions. Be taught Extra.
Thread execution management is a vital facet of growing strong and environment friendly concurrent purposes in Java. Pausing thread execution at particular factors can assist in synchronization, coordination, and avoiding race circumstances. On this programming tutorial, we are going to discover varied methods for pausing thread execution in Java.
Thread.sleep(): Introducing Managed Delays in Java
Essentially the most easy method to pause thread execution is through the use of the Thread.sleep() technique. This technique causes the presently executing thread to sleep for a specified period of time in milliseconds. Whereas easy to make use of, it’s important to understand that Thread.sleep() doesn’t assure exact timing, because the working system’s scheduling can introduce variations within the delay. Builders can use this technique when they should introduce managed delays between thread actions, similar to ready for sources or simulating time-based occasions.
Right here is a few pattern code that makes use of Thread.sleep() to pause for 500 milliseconds between the incrementing and printing of a variable:
class ThreadSleepExample extends Thread {
public void run(){
for(int i=1;i<=5;i++){
attempt {
Thread.sleep(500);
}
catch(InterruptedException e) {
System.out.println(e);
}
System.out.println(i);
}
}
public static void important(String args[]) {
ThreadSleepExample t1 = new ThreadSleepExample();
ThreadSleepExample t2 = new ThreadSleepExample();
t1.begin();
t2.begin();
}
}
/*
Outputs:
1
1
2
2
3
3
4
4
5
5
*/
Learn: Greatest Collaboration Instruments for Java Builders
Object.wait(): Synchronization and Inter-Thread Communication
The Object.wait() technique is used for inter-thread communication and synchronization. It permits a thread to attend till one other thread invokes notify() or notifyAll() on the identical object. This system is particularly helpful when a number of threads have to coordinate their actions based mostly on sure circumstances.
Here’s a pattern Java program to exhibit the way to use the Object.wait() technique:
package deal com.developer;
public class WaitExample {
public static void important(String[] args) {
last Object lock = new Object(); // Shared lock object
// Thread 1 - Waits for a sign to proceed
Thread thread1 = new Thread(() -> {
synchronized (lock) {
System.out.println("Thread 1 is ready...");
attempt {
lock.wait(); // Thread 1 waits till notified
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1 has been notified and resumed.");
}
});
// Thread 2 - Notifies Thread 1 to proceed
Thread thread2 = new Thread(() -> {
attempt {
Thread.sleep(2000); // Wait for two seconds
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock) {
System.out.println("Thread 2 is notifying Thread 1.");
lock.notify(); // Notifying Thread 1 to proceed
}
});
thread1.begin();
thread2.begin();
attempt {
thread1.be a part of();
thread2.be a part of();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Important thread completed.");
}
}
/*
Output:
Thread 1 is ready...
Thread 2 is notifying Thread 1.
Thread 1 has been notified and resumed.
Important thread completed.
*/
On this instance:
- Thread 1 enters a synchronized block utilizing the shared lock object after which calls lock.wait(). This causes Thread 1 to launch the lock and wait till one other thread calls lock.notify() or lock.notifyAll() on the identical lock object.
- Thread 2 begins after a delay of two seconds. It additionally enters a synchronized block utilizing the identical lock object after which calls lock.notify() to get up Thread 1.
- After Thread 2 notifies Thread 1, Thread 1 resumes its execution and prints a message.
Learn: Greatest Instruments for Java Cell Growth
Thread.yield(): Giving Up CPU Time in Java
The Thread.yield() technique suggests to the thread scheduler that the present thread is keen to yield its present time slice. Whereas it doesn’t assure a pause, it’d permit different threads with equal or greater precedence to run. Nonetheless, it is very important be aware that relying solely on Thread.yield() for thread coordination is just not advisable, because it relies on the thread scheduler’s conduct and won’t present constant outcomes throughout completely different Java Digital Machine (JVM) implementations.
Right here is a few instance code displaying the way to use Thread.yield() in Java:
package deal com.developer;
public class YieldExample {
public static void important(String[] args) {
Thread thread1 = new Thread(() -> {
for (int i = 1; i <= 5; i++) {
System.out.println("Thread 1 - Iteration " + i);
Thread.yield(); // Yielding thread execution
}
});
Thread thread2 = new Thread(() -> {
for (int i = 1; i <= 5; i++) {
System.out.println("Thread 2 - Iteration " + i);
Thread.yield(); // Yielding thread execution
}
});
thread1.begin();
thread2.begin();
}
}
/*
Output:
Thread 1 - Iteration 1
Thread 2 - Iteration 1
Thread 1 - Iteration 2
Thread 1 - Iteration 3
Thread 2 - Iteration 2
Thread 2 - Iteration 3
Thread 2 - Iteration 4
Thread 2 - Iteration 5
Thread 1 - Iteration 4
Thread 1 - Iteration 5
*/
Within the above program:
- Thread 1 and Thread 2 are created, every with a easy loop that prints iterations.
- Inside every loop iteration, the Thread.yield() technique is known as. This implies to the thread scheduler that the present thread is keen to yield its present time slice, giving different threads an opportunity to execute.
Once we run this instance, we will see that each threads are yielding their execution alternatively, permitting one another to run. Nonetheless, it’s essential to notice that the precise conduct of Thread.yield() can fluctuate relying on the JVM implementation and the working system’s thread scheduler. In some circumstances, it won’t lead to a big change in execution order, particularly if one thread has greater precedence.
It is usually essential to keep in mind that, whereas Thread.yield() will be helpful in sure eventualities to offer a touch to the thread scheduler, it’s usually not the first method to obtain synchronization and coordination between threads. Extra strong synchronization mechanisms, like wait(), notify(), locks, and superior concurrency utilities, are sometimes most popular for exact management over thread interactions.
Remaining Ideas on Find out how to Pause Thread Execution in Java
Managing thread execution pauses is a vital ability for Java builders constructing concurrent purposes. Whether or not you might be introducing managed delays, synchronizing threads, or using superior concurrency utilities, understanding the methods mentioned on this article will empower you to create strong, environment friendly, and responsive multi-threaded purposes in Java. Do not forget that the selection of approach relies on your particular necessities, and cautious consideration is required to make sure optimum efficiency and synchronization.
Subsequent Steps
Now that you’ve got a greater understanding of the completely different strategies builders can use to pause thread execution, you may wish to think about studying a few of our different Java tutorials specializing in threading, multithreading, and concurrency. We spotlight a couple of beneath to assist get you began:
