Need Information about wait(),notiy(),notifyAll() in java

[Deepak Sahu]

Hi All,


Can someone explain me the detail flow of wait(),notify() and notifyAll() in thread with complete example.

[Vijitha Kumara]

Can someone explain me the detail flow of wait(),notify() and notifyAll()...

Invocation of wait() causes the the current thread to wait until some other thread invokes notify()/notifyAll() for the same object which the wait() was invoked. You may want to look at concurrency tutorial to know more about concurrency here

[Thakur Sachin Singh]

wait(), notify(), notifyAll() inherited from Object class...all three methods work on same object.

[Steve Luke]

Hi Deepak,

Below you will see one example workflow for using Object.wait(), Object.notify(), and Object.notifyAll() for synchronizing multiple threads in Java.

There are many different reasons to synchronize between threads in Java, and so there are also multiple different paradigms for using the synchronized blocks, wait(), and notify() methods. What they all have in common would be the sharing of data and the need to signal some condition is met. You can take the wait() method as meaning 'I want to pause until the condition is met.' In this case, a notify() means 'The condition has been met. Let ONE wait()er know.' The notifyAll() then becomes 'The condition has been met. Let ALL wait()ers know.' In this situation, Object on which the wait(), notify(), or notifyAll() methods are called on represents the 'condition.' Since all the wait()ers and notify()ers want to work and notify on the same condition, they need access to the same Object. If they need to wait() or notify() on different conditions they would often use different Objects, or add an additional signal like a boolean flag.

It is not uncommon to require tasks to switch back and forth, one thread doing a portion of a task, and signaling to the other thread to continue. Then at some point needing to wait for the second thread to signal it is done. This this case you usually have each thread alternating between wait() and notify().

There are a few things that you have to be aware of:
1) If the notifier calls notify() before the waiter calls wait(), the waiter will not see it. This can sometimes lead to the waiter never getting a signal and blocking indefinitely. So there is often the need to send a boolean which says 'Signal was sent already, don't wait' as well as the notify().
2) There is also a chance of a 'spurious' wakeup which can cause the waiter to be notified even when the notifier has not yet sent its signal. This also is usually solved by using a boolean in addition to the normal notify().

The result is that you often will use a wait() something like this:

synchronized(signal)
{
    while(notNotified)
    {
        signal.wait();
    }
}

or some variation. Then the notifier does:

synchronized(signal)
{
    notNotified = false;
    signal.notify();
}

This would solve both of the notes above. Also note that I did not use that mechanism in my code below because it wasn't really necessary.

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

public class Synching 
{
	/**
	 * The Waiter class represents some task which will 'wait()' on a signal.  This is often a 'consumer' which must wait for data to arrive,
	 * or some task which must wait on a specific event to occur.
	 */
	public static class Waiter extends Synching implements Runnable
	{   /** The signal is the Object used for synchronizing between Threads.  */
		private final Object signal;

		/**
		 * @param condition The Waiter must wait() for some condition to be met.  The Object passed in represents that Condition.  The condition
		 * 					object will be used to synchronize on, and will be used to wait() on.
		 */
		public Waiter(Object condition)
		{
			this.signal = condition;
		}
		
		public void run()
		{
			this.setThread(Thread.currentThread());
			
			/* The canRun() method is inherited from Synching.  This task will loop forever until stop() is called. */
			while(this.canRun())
			{
				try
				{   
					System.out.println("Waiter " + this.id + " is starting to wait.");
					
					/* Note: synchronized and wait() on the same object. */
					synchronized(signal)
					{
						signal.wait();
					}
					
					/* Simulate doing something for real... */
					System.out.println("Waiter " + this.id + " has been woken up, and will do some work.");
					doWork();
				} catch (InterruptedException ie)
				{   /* stop() may interrupt the thread.  If it does, than canRun() will return false, and the interrupt is not an error... */
					if (this.canRun())
					{
						System.err.println("Waiter " + this.id + " has been interrupted erroneously.  Continueing on.");
					}
				}
			}
			System.out.println("Waiter " + this.id + " will shutdown.");
		}
	}
	
	/**
	 * The Notifier class represents some task which will 'notify()' or 'notifyAll()' wait()ers.  This is often a 'producer' which signals that data is available
	 * so consumers can begin consuming.  It could be any other task which may cause an event to occur.
	 */
	public static class Notifier extends Synching implements Runnable
	{
		private final Object signal;
		
		/**
		 * @param condition The Notifier will notify() wait()ing threads that some condition has been met.  The Object passed in represents that condition.  The condition
		 * 					object will be used to synchronize on, and will be used to notify() or notifyAll() from.
		 */
		public Notifier(Object condition)
		{
			this.signal = condition;
		}
		
		public void run()
		{
			while (this.canRun())
			{
				try
				{
					System.out.println("Notifier will do some work before sending signal.");
					this.doWork();
					
					System.out.println("Notifier is about to send signal to just one Waiter.");
					synchronized(signal)
					{
						signal.notify();
					}
					
					System.out.println("Notifier will do some more work...");
					this.doWork();
					
					System.out.println("Notifier will wake up every waiting Waiter.");
					synchronized(signal)
					{
						signal.notifyAll();
					}
				} catch (InterruptedException ie)
				{
					if (this.canRun())
					{
						System.err.println("Notifier has been interrupted erroneously.  Continuing on");
					}
				}
			}
			System.out.println("Notifier will shutdown.");
		}
	}

	public static void main(String[] args) 
	{	/* The signal Object here is the 'condition' that the Waiters will wait() on and the
	 	 * Notifier will use for sending conditions on.  The Waiters and Notifier must use the SAME
	 	 * Object for signaling with.  So created it once then pass it to all necessary instances...
	     */
		Object signal = new Object();
		
		/* Creating multiple waiters so you should see a difference between a notify() and notifyAll() */
		Waiter[] waiters = new Waiter[3];		
		for (int i = 0; i < waiters.length; i++)
		{
			waiters[i] = new Waiter(signal);
			new Thread(waiters[i]).start();
		}
		
		Notifier notifier = new Notifier(signal);
		new Thread(notifier).start();
		
		/* Let the signaling happen for a while, then stop everything... */
		try
		{
			Thread.sleep(2000);
		} catch (InterruptedException ie)
		{
			//don't care
		}
		
		for (int i = 0; i < waiters.length; i++)
		{
			waiters[i].stop();
		}
		notifier.stop();
		
	}
	
	private static final AtomicInteger counter = new AtomicInteger();
	protected final int id = counter.incrementAndGet();
	private Random random = new Random();
	
	/*
	 * The rest of this code is used to simplify the 'shutdown' process.  It is not integral to the wait()/notify()
	 * example.  It allows us to stop tasks from running indefinitely in a safe manner.
	 */
	private volatile boolean doRun = true;
	private volatile Thread runningThread;
	
	protected void setThread(Thread thisThread)
	{
		this.runningThread = thisThread;
	}
	
	protected boolean canRun()
	{
		return this.doRun;
	}
	
	public void stop()
	{
		this.doRun = false;
		
		if (this.runningThread != null)
		{
			this.runningThread.interrupt();
		}
	}
	
	protected void doWork() throws InterruptedException
	{
		int workTime = random.nextInt(200);
		Thread.sleep(workTime);
	}

	/*
	 * Example Output
	 * <code>
	 * Waiter 1 is starting to wait.
	 * Waiter 3 is starting to wait.
	 * Waiter 2 is starting to wait.
	 * Notifier will do some work before sending signal.
	 * Notifier is about to send signal to just one Waiter.
	 * Notifier will do some more work...
	 * Waiter 1 has been woken up, and will do some work.
	 * Notifier will wake up every waiting Waiter.
	 * Waiter 2 has been woken up, and will do some work.
	 * Waiter 3 has been woken up, and will do some work.
	 * Notifier will do some work before sending signal.
	 * Waiter 1 is starting to wait.
	 * Waiter 3 is starting to wait.
	 * Waiter 2 is starting to wait.
	 * Notifier is about to send signal to just one Waiter.
	 * Notifier will do some more work...
	 * Waiter 1 has been woken up, and will do some work.
	 * ...
	 * Notifier will do some more work...
	 * Waiter 3 is starting to wait.
	 * Waiter 3 will shutdown.
	 * Waiter 2 will shutdown.
	 * Waiter 1 will shutdown.
	 * Notifier will wake up every waiting Waiter.
	 * Notifier will shutdown.
	 * </code>
	 */
}