Wait and Notify

[adithya narayan]

Hi,

I wrote a program which will have two threads; one thread will check for numbers between 1 to 100 and if encounters any number which is a multiple of 10 (modulus) then notify the second thread ,so that it will carry out a special operation on the same number.

Below is the code i have written :

public class WaitAndNotifyTest implements Runnable 
{
	int modulo = 0;
	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		WaitAndNotifyTest notifyRunnable = new WaitAndNotifyTest();
		WaitingRunnable waitingRunnable = new WaitingRunnable(notifyRunnable);
		
		Thread waitingThread = new Thread(waitingRunnable);
		Thread notifyThread = new Thread(notifyRunnable);
		
		waitingThread.start();
		notifyThread.start();
	}

	@Override
	public void run() 
	{
		for(int i = 0 ; i < 100 ; i++)
		{
			synchronized (this) 
			{
				if(i%10 == 0)
				{
					System.out.println("Before calling notify ,i = "+i);
					modulo = i;
					notify();
					System.out.println("After calling notify ,i= "+i);
				}
			}
		}
	}
}

class WaitingRunnable implements Runnable
{
	private WaitAndNotifyTest waitAndNotifyTest = null;
	
	public WaitingRunnable(WaitAndNotifyTest waitAndNotifyTest) 
	{
		this.waitAndNotifyTest = waitAndNotifyTest;
	}

	@Override
	public void run() 
	{
		while(true)
		{
			synchronized (waitAndNotifyTest) 
			{
				try 
				{
					waitAndNotifyTest.wait();
					System.out.println(waitAndNotifyTest.modulo+"ñ");
				}
				catch (InterruptedException e) 
				{
					e.printStackTrace();
				}
			}
		}
	}
}

I was expecting the output to be something like this :

Before calling notify ,i = 0
0ñ
After calling notify ,i= 0
Before calling notify ,i = 10
10ñ
After calling notify ,i= 10
Before calling notify ,i = 20
20ñ
After calling notify ,i= 20
Before calling notify ,i = 30
30ñ
After calling notify ,i= 30
.
.
.
Before calling notify ,i = 100
100ñ
After calling notify ,i= 100

..but it didn't happen so !

instead it printed some like this

First output:

Before calling notify ,i = 0
After calling notify ,i= 0
Before calling notify ,i = 10
After calling notify ,i= 10
Before calling notify ,i = 20
After calling notify ,i= 20
Before calling notify ,i = 30
After calling notify ,i= 30
Before calling notify ,i = 40
After calling notify ,i= 40
Before calling notify ,i = 50
After calling notify ,i= 50
Before calling notify ,i = 60
After calling notify ,i= 60
Before calling notify ,i = 70
After calling notify ,i= 70
Before calling notify ,i = 80
After calling notify ,i= 80
Before calling notify ,i = 90
After calling notify ,i= 90
90ñ

Second output:

Before calling notify ,i = 0
After calling notify ,i= 0
Before calling notify ,i = 10
After calling notify ,i= 10
Before calling notify ,i = 20
After calling notify ,i= 20
Before calling notify ,i = 30
After calling notify ,i= 30
Before calling notify ,i = 40
After calling notify ,i= 40
Before calling notify ,i = 50
After calling notify ,i= 50
Before calling notify ,i = 60
After calling notify ,i= 60
60ñ
Before calling notify ,i = 70
After calling notify ,i= 70
70ñ
Before calling notify ,i = 80
After calling notify ,i= 80
80ñ
Before calling notify ,i = 90
After calling notify ,i= 90
90ñ

1)Can anyone explain what went wrong?
2)The program didn't terminate. How do i terminate it?


Thanks,
Adithya.

[Henry Wong]

adithya narayan wrote:
1)Can anyone explain what went wrong?
2)The program didn't terminate. How do i terminate it?

A few points...

1. The notify() method doesn't trigger the wakeup, context switch, etc.... all it does is send the notification to a waiting thread.
2. A notification that is sent, and there is no waiting thread, is ignored.
3. The wait and notify mechanism is integrated with the synchronization mechanisms because there are race conditions that need to be taken care of.

so...

Your waitandnotifytest thread just sends the notification, and does so blindly in a loop (no flag to confirm receipt, or that a thread is waiting)... see point one and two. This causes a bunch of missed notifications.


And the reason your program doesn't end is because your waitingrunnable thread has an endless loop.

Henry

[adithya narayan]

Hi Henry,


ahhh..right i completely overlooked that the code was running in an infinite loop !

But it still doesn't make it any clear to me as to why certain notifications weren't caught by the waiting thread !!

I was under the impression that :

1)When a synchronized block is executing (by holding the lock on a third party object) no other object can enter that block or acquire the object's lock. Also when one wants to call wait/notify on an object it needs to acquire the object's lock. So according to my understanding the waiting thread calls wait and releases the object lock so other threads can use it.
Now the notifying thread acquires the lock performs certain operations inside the synchronized block and calls notify. As soon as it exits the synchronized block it releases the object lock.
Next the waiting thread comes out from the blocking state ,acquires the object lock and performs the necessary operations. Meanwhile ,if the notifying thread wants to enter the synchronized block again it will require the object lock !!
So,i thought the expected and actual output would match.

I am not able to figure out what i am missing.

I understood why you pointed out the following to me :

The notify() method doesn't trigger the wakeup, context switch, etc.... all it does is send the notification to a waiting thread.

and that's because my following piece of code was misleading:

System.out.println("After calling notify ,i= "+i);  

I should have written that in the waiting thread.
as

System.out.println("After calling notify ,i= "+waitandnotifytest .modulo);  

Your second point is also understood


I didn't understand the condition you were talking about. I really didn't feel that there should be condition which will monitor the wait/notify events. Please clarify if i am missing anything.

Your waitandnotifytest thread just sends the notification, and does so blindly in a loop (no flag to confirm receipt, or that a thread is waiting)... see point one and two. This causes a bunch of missed notifications.

Why does it cause notifications to be missed ?


Thanks,
Adithya.

[Steve Luke]

You expect things to happen in a specific order:

1: The waiter waits
2: The notifier notifies
3: The waiter gets signal and works
-- repeat

But this isn't guaranteed. What can happen is the notifier notifies before the waiter waits. In this case, the waiter never sees the notify. Additionally, once the notify is sent, it does not ensure that the waiter gets the lock next. What actually happens is that the waiter and notifier 'compete' for the lock. So the notifier may get the lock and send another signal, and another, and another before the waiter ever gets a chance to respond.

If it is important that the waiter respond to every notify then you need two way signaling, like a flag which the waiter sets to let the notifier know it is ready, or a return signal which let's the notifier know its signal was received.

[adithya narayan]

I get it now to an extent ! I modified my code accordingly and got near about to the output i wanted.

Below is the code :

public class WaitAndNotifyTest implements Runnable 
{
	int modulo = 0;
	boolean isWaiting = true;
//	boolean increment = false;
	FileWriter fileWriter = null;
	
	public WaitAndNotifyTest() 
	{
		try 
		{
			fileWriter = new FileWriter(new File("E:/sop.txt"));
		}
		catch (IOException e) 
		{
			e.printStackTrace();
		}
	}
	
	FileWriter getFileWriter()
	{
		return fileWriter;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		WaitAndNotifyTest notifyRunnable = new WaitAndNotifyTest();
		WaitingRunnable waitingRunnable = new WaitingRunnable(notifyRunnable,notifyRunnable.getFileWriter());
		
		Thread waitingThread = new Thread(waitingRunnable);
		Thread notifyThread = new Thread(notifyRunnable);
		
		waitingThread.start();
		notifyThread.start();
	}

	@Override
	public void run() 
	{
		int i=0;
		while(i <= 100)
		{
			System.out.println("Notifying thread working on "+i);
			try
			{
				fileWriter.write("Notifying thread working on "+i+"\n");
			} 
			catch (IOException e)
			{
				e.printStackTrace();
			}
			
			if(i%10 == 0 && isWaiting)
			{
				synchronized (this) 
				{
					System.out.println("Before calling notify ,i = " +i);
					
					try 
					{
						fileWriter.write("Before calling notify ,i = " +i+"\n");
					}
					catch (IOException e) 
					{
						e.printStackTrace();
					}
					modulo = i;
					notify();
					isWaiting = false;
				}
			}
			if((i%10 != 0 || modulo == i))
				i++;
		}
	}
}

class WaitingRunnable implements Runnable
{
	private WaitAndNotifyTest waitAndNotifyTest = null;
	FileWriter fileWriter = null; 
	
	public WaitingRunnable(WaitAndNotifyTest waitAndNotifyTest,FileWriter fileWriter) 
	{
		this.waitAndNotifyTest = waitAndNotifyTest;
		this.fileWriter = fileWriter;
	}

	@Override
	public void run() 
	{
		while(true)
		{
			synchronized (waitAndNotifyTest) 
			{
				try 
				{
					waitAndNotifyTest.wait();
					
					System.out.println("Waiting thread modified value to "+waitAndNotifyTest.modulo+"ñ"+"\n");
					System.out.println("After calling notify and activating waiting thread ,i is "+waitAndNotifyTest.modulo);
					try 
					{
						fileWriter.write("Waiting thread modified value to "+waitAndNotifyTest.modulo+"ñ"+"\n");
						fileWriter.write("After calling notify and activating waiting thread ,i is "+waitAndNotifyTest.modulo+"\n");
					}
					catch (IOException e) 
					{
						e.printStackTrace();
					}
					if(waitAndNotifyTest.modulo == 100)
					{
						try 
						{
							fileWriter.close();
						} 
						catch (IOException e) 
						{
							e.printStackTrace();
						}
						break;
					}
					waitAndNotifyTest.isWaiting = true;
				}
				catch (InterruptedException e) 
				{
					e.printStackTrace();
				}
			}
		}
	}
}

and the output is as follows:

Notifying thread working on 0
Before calling notify ,i = 0
Notifying thread working on 1
Notifying thread working on 2
Notifying thread working on 3
Notifying thread working on 4
Waiting thread modified value to 0ñ
After calling notify and activating waiting thread ,i is 0
Notifying thread working on 5
Notifying thread working on 6
Notifying thread working on 7
Notifying thread working on 8
Notifying thread working on 9
Notifying thread working on 10
Before calling notify ,i = 10
Waiting thread modified value to 10ñ
After calling notify and activating waiting thread ,i is 10
Notifying thread working on 11
Notifying thread working on 12
Notifying thread working on 13
Notifying thread working on 14
Notifying thread working on 15
Notifying thread working on 16
Notifying thread working on 17
Notifying thread working on 18
Notifying thread working on 19
Notifying thread working on 20
Before calling notify ,i = 20
Notifying thread working on 21
Notifying thread working on 22
Notifying thread working on 23
Notifying thread working on 24
Notifying thread working on 25
Notifying thread working on 26
Notifying thread working on 27
Notifying thread working on 28
Notifying thread working on 29
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Notifying thread working on 30
Waiting thread modified value to 20ñ
After calling notify and activating waiting thread ,i is 20
Notifying thread working on 30
Before calling notify ,i = 30
Waiting thread modified value to 30ñ
After calling notify and activating waiting thread ,i is 30
Notifying thread working on 31
Notifying thread working on 32
Notifying thread working on 33
Notifying thread working on 34
Notifying thread working on 35
Notifying thread working on 36
Notifying thread working on 37
Notifying thread working on 38
Notifying thread working on 39
Notifying thread working on 40
Before calling notify ,i = 40
Notifying thread working on 41
Notifying thread working on 42
Notifying thread working on 43
Notifying thread working on 44
Notifying thread working on 45
Waiting thread modified value to 40ñ
After calling notify and activating waiting thread ,i is 40
Notifying thread working on 46
Notifying thread working on 47
Notifying thread working on 48
Notifying thread working on 49
Notifying thread working on 50
Before calling notify ,i = 50
Notifying thread working on 51
Waiting thread modified value to 50ñ
After calling notify and activating waiting thread ,i is 50
Notifying thread working on 52
Notifying thread working on 53
Notifying thread working on 54
Notifying thread working on 55
Notifying thread working on 56
Notifying thread working on 57
Notifying thread working on 58
Notifying thread working on 59
Notifying thread working on 60
Before calling notify ,i = 60
Waiting thread modified value to 60ñ
After calling notify and activating waiting thread ,i is 60
Notifying thread working on 61
Notifying thread working on 62
Notifying thread working on 63
Notifying thread working on 64
Notifying thread working on 65
Notifying thread working on 66
Notifying thread working on 67
Notifying thread working on 68
Notifying thread working on 69
Notifying thread working on 70
Before calling notify ,i = 70
Waiting thread modified value to 70ñ
After calling notify and activating waiting thread ,i is 70
Notifying thread working on 71
Notifying thread working on 72
Notifying thread working on 73
Notifying thread working on 74
Notifying thread working on 75
Notifying thread working on 76
Notifying thread working on 77
Notifying thread working on 78
Notifying thread working on 79
Notifying thread working on 80
Before calling notify ,i = 80
Waiting thread modified value to 80ñ
After calling notify and activating waiting thread ,i is 80
Notifying thread working on 81
Notifying thread working on 82
Notifying thread working on 83
Notifying thread working on 84
Notifying thread working on 85
Notifying thread working on 86
Notifying thread working on 87
Notifying thread working on 88
Notifying thread working on 89
Notifying thread working on 90
Before calling notify ,i = 90
Waiting thread modified value to 90ñ
After calling notify and activating waiting thread ,i is 90
Notifying thread working on 91
Notifying thread working on 92
Notifying thread working on 93
Notifying thread working on 94
Notifying thread working on 95
Notifying thread working on 96
Notifying thread working on 97
Notifying thread working on 98
Notifying thread working on 99
Notifying thread working on 100
Before calling notify ,i = 100
Waiting thread modified value to 100ñ
After calling notify and activating waiting thread ,i is 100

This is how wait and notify works i guess. The notifying thread notifies the worker thread that it can stop waiting and continue its execution and meanwhile the notifying thread executes its own operation. Am i right? Also i have kept a check to ensure that each and every notification is captured by the waiting thread by using the flag

isWaiting

.

So,the notifying thread cannot re-enter the synchronized block until the waiting thread finishes its previous execution; till then the notifying thread is blocked.

I am still unable to get to the output which i had desired i.e. The notifying thread should increment the value of the counter only after the waiting thread finishes its previous execution based on the notification sent by the notifying thread ! Also,the notifying thread shouldn't notify for the same event again. Can anyone suggest something ?


Thanks,
Adithya.

[Henry Wong]

adithya narayan wrote:
I am still unable to get to the output which i had desired i.e. The notifying thread should increment the value of the counter only after the waiting thread finishes its previous execution based on the notification sent by the notifying thread ! Also,the notifying thread shouldn't notify for the same event again. Can anyone suggest something ?

Correct. That is what you need to do. Right now, all you do is to not do another notify, you don't wait, you just move on to the next value.

Henry

[adithya narayan]

I want to move to the next value only if the waiting thread has finished its execution.

Something like
1)i=1,2,3,4,5,6,7,8,9, 10..meanwhile,waiting thread is waiting (lets forget 0 for time being)
2)now notification happens and is blocked until waiting thread executes its work and tells the notifying thread to resume..
3)now notifying thread continues i=11,12,13,14,15,16,17,18,19,20..the same process continues
.
.
.
and so on.

I did think of many options but i am seeing one possibility of both the threads having the roles of waiting and notifying..i fear deadlock might occur.

Thanks,
Adithya.

[Steve Luke]

You should be able to use wait() and notify() like this. The counting thread would first wait() for a signal from the WaitingRunnable so it knows the WaitingRunnable is actually waiting. Then it sends a notify(), then it wait()s for when the WaitingRunnable is done. Meanwhile the WaitingRunnable first notify()s that it is going to wait. It then wait()s, does its work, and then notify()s. You would need booleans to check and prevent extra wait()s from occurring. It can be a bit tricky.

So a better option might be to employ one of the signaling mechanisms in the java.util.concurrent package. I am thinking either an exchanger or CyclicBarrier. The Exchanger may be best since you want to share data - it can prevent the need for sharing the modulo value all together (just pass it back and forth). Here is an example:

package concurrency;

import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.Exchanger;

public class TenCounter 
{
	private final FileWriter fileWriter;
	private final Exchanger<Integer> counterExchanger = new Exchanger<Integer>();

	/* These two variables are Exchanger return values.  They are sent by the NumberConsumer to indicate wether the Producer should
	 * continue producing or if it should wait for another exchange to occur.
	 */
	private final Integer producerCanProceed = -1;
	private final Integer producerShouldWait = 0;

	public TenCounter(String logFile)
	{
		try
		{
			this.fileWriter = new FileWriter(logFile);
		} catch (Exception e)
		{
			throw new IllegalArgumentException ("Can't make a file for " + logFile, e);
		}
	}
	
	class NumberProducer implements Runnable
	{
		public void run()
		{
			int i=0;
			while(i <= 100)
			{
				System.out.println("Notifying thread working on "+i);
				try
				{
					fileWriter.write("Notifying thread working on "+i+"\n");
				} 
				catch (IOException e)
				{
					e.printStackTrace();
				}
				
				if(i%10 == 0)
				{
					/* Initially assume that the Producer can't proceed.  Then continue to try to exchange until the Consumer
					 * sends the producerCanProceed object.
					 */
					Integer canProceed = producerShouldWait;
					while (canProceed != producerCanProceed)
					{
						try
						{   /* Exchanger is a two way gate.  Send the current count.  Get notification on proceeding. */
							canProceed = counterExchanger.exchange(i);
						} catch (InterruptedException ie)
						{
							System.err.println("Producer was interrupted while waiting for exchange. Trying again.");
							ie.printStackTrace();
						}
					}
				}
				
				i++;
			}
			
			System.out.println("Producer is done.");
		}
	}
	
	class NumberConsumer implements Runnable
	{
		public void run()
		{
			while(true)
			{
				synchronized (TenCounter.this) 
				{   /* modulo is now a local variable we will get from the Exchanger. */
					int modulo = -1;
					/* wait for a good value to come in via the exchanger */
					while (modulo == -1)
					{
						try
						{  /* When getting a modulo value, tell the producer it should wait. */
							modulo = counterExchanger.exchange(producerShouldWait);
						} catch (InterruptedException ie)
						{
							System.err.println("Consumer interrupted waiting for exchange.  Trying again.");
							ie.printStackTrace();
						}
					}

					System.out.println("After calling notify and activating waiting thread ,i is "+ modulo);

					try 
					{
						fileWriter.write("After calling notify and activating waiting thread ,i is "+modulo+"\n");
					}
					catch (IOException e) 
					{
						e.printStackTrace();
					}

					/* Ready to tell producer to proceed.  Producer will resent the current count.  */
					int producerResponse = -1;
					while (producerResponse != modulo)
					{
						try
						{
							producerResponse = counterExchanger.exchange(producerCanProceed);
						} catch (InterruptedException ie)
						{
							System.err.println("Consumer was interrupted informing Producer to continue.  Trying again.");
							ie.printStackTrace();
						}
					}

					if(modulo == 100)
					{
						try 
						{
							fileWriter.close();
						} 
						catch (IOException e) 
						{
							e.printStackTrace();
						}
						
						break;
					}
				}
			}
			
			System.out.println("Consumer is done.");
		}
	}
	
	public static void main(String[] args) 
	{
		TenCounter counter = new TenCounter("C:\\sop.txt");
		NumberProducer producer = counter.new NumberProducer();
		NumberConsumer consumer = counter.new NumberConsumer();
		
		Thread producerThread = new Thread(producer, "Producer");
		Thread consumerThread = new Thread(consumer, "Consumer");
		
		producerThread.start();
		consumerThread.start();
	}

}