Java.lang.Object.wait() Method

Advertisements


Description

The java.lang.Object.wait(long timeout, int nanos) causes current thread to wait until either another thread invokes the notify() method or the notifyAll() method for this object, or a specified amount of time has elapsed.

This method is similar to the wait method of one argument, but it allows finer control over the amount of time to wait for a notification before giving up. The amount of real time, measured in nanoseconds, is given by:

1000000*timeout+nanos

In all other respects, this method does the same thing as the method wait(long) of one argument. In particular, wait(0, 0) means the same thing as wait(0).

The current thread must own this object's monitor.

Declaration

Following is the declaration for java.lang.Object.wait() method

public final void wait(long timeout, int nanos)

Parameters

  • timeout -- the maximum time to wait in milliseconds.

  • nanos -- additional time, in nanoseconds range 0-999999.

  • Return Value

    This method does not return a value.

    Exception

    • IllegalArgumentException -- if the value of timeout is negative or the value of nanos is not in the range 0-999999.

    • IllegalMonitorStateException -- if the current thread is not the owner of the object's monitor.

    • InterruptedException -- if another thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.

    Example

    The following example shows the usage of lang.Object.wait() method.

    package com.tutorialspoint;
    
    import java.util.Collections;
    import java.util.LinkedList;
    import java.util.List;
    
    public class ObjectDemo extends Object {
    
       private List synchedList;
    
       public ObjectDemo() {
          // create a new synchronized list to be used
          synchedList = Collections.synchronizedList(new LinkedList());
       }
    
       // method used to remove an element from the list
       public String removeElement() throws InterruptedException {
          synchronized (synchedList) {
    
             // while the list is empty, wait up to 10 seconds and 500 nanos
             while (synchedList.isEmpty()) {
                System.out.println("List is empty...");
                synchedList.wait(10000, 500);
                System.out.println("Waiting...");
             }
             String element = (String) synchedList.remove(0);
    
             return element;
          }
       }
    
       // method to add an element in the list
       public void addElement(String element) {
          System.out.println("Opening...");
          synchronized (synchedList) {
    
             // add an element and notify all that an element exists
             synchedList.add(element);
             System.out.println("New Element:'" + element + "'");
    
             synchedList.notifyAll();
             System.out.println("notifyAll called!");
          }
          System.out.println("Closing...");
       }
    
       public static void main(String[] args) {
          final ObjectDemo demo = new ObjectDemo();
    
          Runnable runA = new Runnable() {
    
             public void run() {
                try {
                   String item = demo.removeElement();
                   System.out.println("" + item);
                } catch (InterruptedException ix) {
                   System.out.println("Interrupted Exception!");
                } catch (Exception x) {
                   System.out.println("Exception thrown.");
                }
             }
          };
    
          Runnable runB = new Runnable() {
    
             // run adds an element in the list and starts the loop
             public void run() {
                demo.addElement("Hello!");
             }
          };
    
          try {
             Thread threadA1 = new Thread(runA, "A");
             threadA1.start();
    
             Thread.sleep(500);
    
             Thread threadA2 = new Thread(runA, "B");
             threadA2.start();
    
             Thread.sleep(500);
    
             Thread threadB = new Thread(runB, "C");
             threadB.start();
    
             Thread.sleep(1000);
    
             threadA1.interrupt();
             threadA2.interrupt();
          } catch (InterruptedException x) {
          }
       }
    }
    
    

    Let us compile and run the above program, this will produce the following result:

    List is empty...
    List is empty...
    Opening...
    New Element:'Hello!'
    notifyAll called!
    Closing...
    Waiting...
    Hello!
    Waiting...
    List is empty...
    Interrupted Exception!
    



    Advertisements
    Advertisements