Developer.com content material and product suggestions are editorially impartial. We could become profitable while 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 functions in Java. Pausing thread execution at particular factors may also help in synchronization, coordination, and avoiding race circumstances. On this programming tutorial, we’ll discover numerous strategies for pausing thread execution in Java.

Thread.sleep(): Introducing Managed Delays in Java

Probably the most simple strategy to pause thread execution is through the use of the Thread.sleep() methodology. This methodology 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 methodology when they should introduce managed delays between thread actions, similar to ready for assets 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&lt=5;i++){   
        attempt {
          Thread.sleep(500);
        }
        catch(InterruptedException e) {
          System.out.println(e);
        }    
        System.out.println(i);    
      }    
    }    
    public static void principal(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() methodology 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 method is very helpful when a number of threads must coordinate their actions based mostly on sure circumstances.

Here’s a pattern Java program to show how you can use the Object.wait() methodology:

bundle com.developer;

public class WaitExample {
  public static void principal(String[] args) {
    ultimate 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 part of();
      thread2.be 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:

1. 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.
2. 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.
3. 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() methodology suggests to the thread scheduler that the present thread is prepared to yield its present time slice. Whereas it doesn’t assure a pause, it would enable different threads with equal or increased precedence to run. Nonetheless, it is very important word that relying solely on Thread.yield() for thread coordination will not be really helpful, because it depends upon the thread scheduler’s habits and may not present constant outcomes throughout completely different Java Digital Machine (JVM) implementations.

Right here is a few instance code exhibiting how you can use Thread.yield() in Java:

bundle com.developer;

public class YieldExample {
  public static void principal(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() methodology is known as. This implies to the thread scheduler that the present thread is prepared to yield its present time slice, giving different threads an opportunity to execute.

After 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 habits of Thread.yield() can differ relying on the JVM implementation and the working system’s thread scheduler. In some instances, it may not end in a major change in execution order, particularly if one thread has increased precedence.

It’s also essential to do not forget that, whereas Thread.yield() might be helpful in sure eventualities to offer a touch to the thread scheduler, it’s typically not the first strategy 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.

Ultimate Ideas on How you can Pause Thread Execution in Java

Managing thread execution pauses is a crucial talent for Java builders constructing concurrent functions. Whether or not you’re introducing managed delays, synchronizing threads, or using superior concurrency utilities, understanding the strategies mentioned on this article will empower you to create strong, environment friendly, and responsive multi-threaded functions in Java. Do not forget that the selection of method depends upon your particular necessities, and cautious consideration is required to make sure optimum efficiency and synchronization.

Subsequent Steps

Now that you’ve 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 just a few under to assist get you began: