The java.lang.Object.wait() causes current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).
The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.
This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.
The wait() method is provided by the Object class in Java. This method is used for inter-thread communication in Java. The java.lang.Object.wait() is used to pause the current thread, and wait until another thread does not call the notify() or notifyAll() method. Its syntax is given below.
public final void wait()
Difference between Wait and Sleep in Java
In Java, wait and sleep are the concept of multithreading. Wait and Sleep are the methods used to pause a process for few seconds and go a thread in the waiting state, respectively. Let's understand both of them one by one to get more information about them.
Sleep()
The Sleep () method is related to the Thread class that is used to stop the execution of the current Thread for few seconds. The Sleep () method takes the sleeping time in milliseconds. The monitor's ownership is not lost when we use the Sleep () method and start the execution again from where it stops. In simple words, the Sleep() method is responsible for sending the current Thread into the "Non Runnable" state.
Wait()
The Wait() method is related to the Object class. The Wait() method is responsible for sending the calling thread into the waiting state. The Thread remains in the waiting state until another thread doesn't invoke the notify() or notifyAll() method for that object. The Thread resumes the execution after obtaining the ownership of the monitor.
Before understanding the differences between both of them, let's understand the similarities between them. So, both the Wait() and Sleep() methods are the native methods that make the current Thread go into the Non-Runnable State.
Let's take an example to understand the similarities of both of them.
WaitSleepSimilaritiesExample.java
- class WaitSleepSimilaritiesExample
- {
-
-
- private static Object obj = new Object();
-
-
- public static void main(String[] args)throws InterruptedException
- {
-
-
- Thread.sleep(2000);
-
-
- System.out.println( Thread.currentThread().getName() +
- " Thread is woken after two second");
-
-
- synchronized (obj)
- {
-
- obj.wait(2000);
-
- System.out.println(obj + " Object is in waiting state and woken after 2 seconds");
- }
- }
- }
Output
Difference b/w Wait() and Sleep()
Let's understand the difference between Wait () and Sleep() method:
| Sr. No. | Wait() | Sleep() |
|---|
| 1. | The Wait() method is related to the Object class. | The Sleep () method is related to the Thread class. |
| 2. | | The Sleep () method does not release the lock on the object during Synchronization. |
| 3. | It is not a static method. | It is a static method. |
| 4. | At the time of the Synchronization, the Wait() method releases obj. | At the time of the Synchronization, the Sleep() method doesn't release the obj, i.e., lock. |
| 5. | We can call the Wait () method only from the Synchronized context. | We can call the Sleep () method from outside the Synchronized context. |
| 6. | The Sleep() method has two overloaded methods, which are as follows:- sleep(long milliseconds, int nanoseconds)
- sleep(long milliseconds)
| The Sleep() method has three overloaded methods, which are as follows:- Wait()
- wait(long timeout, int nanoseconds)
- wait(long timeout)
|
| 7. | The constructor of the Wait() method is defined in the following way:
public final void Wait(long timeout) | The constructor of the Sleep () method in the following way:
public static void Sleep (long millis) throws Interrupted_Execption |
Declaration
Following is the declaration for java.lang.Object.wait() method
public final void wait()
Parameters
NA
Return Value
This method does not return a value.
Exception
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
while (synchedList.isEmpty()) {
System.out.println("List is empty...");
synchedList.wait();
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) {
}
}
}
