Thread wait() and notify()

[ManChun Lam]

To understand wait() and notify(), I modified an existing Producer-Consumer pattern code. I got how threads communicate with each other but the output of the following code baffles me.

package com.manchunlam.ThreadTutorial3;
 
// A correct implementation of a producer and consumer.
class Shared
{
    int sharedNumber;
    boolean valueSet;
    boolean maxHit;
 
    public Shared()
    {
        sharedNumber = 0;
        valueSet = false;
        maxHit = false;
    }
 
    synchronized boolean getMaxHit()
    {
        return maxHit;
    }
    synchronized int get()
    {
        if ((maxHit == false) && (valueSet == false))
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                System.out.println("InterruptedException caught");
            }
        }
 
        System.out.println(Thread.currentThread().getName() + " Got: "
                + sharedNumber);
 
        valueSet = false;
 
        notify();
 
        return sharedNumber;
    }
 
    synchronized void put(int n)
    {
        if ((maxHit == false) && (valueSet == true))
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                System.out.println("InterruptedException caught");
            }
        }
 
        if (sharedNumber > 2)
        {
            maxHit = true;
        }
        else
        {
            sharedNumber = n;
        
        valueSet = true;

        System.out.println(Thread.currentThread().getName() + " Put: "
                + sharedNumber);
        }
        
        notify();
    }
}
 
class Producer implements Runnable
{
    Shared s;
 
    Producer(Shared someShared)
    {
        s = someShared;
    }
 
    public void run()
    {
        int i = 0;
 
        while (!s.getMaxHit())
        {
            s.put(i);
            i++;
        }
    }
}
 
class Consumer implements Runnable
{
    Shared s;
 
    Consumer(Shared someShared)
    {
        s = someShared;
    }
 
    public void run()
    {
        while (!s.getMaxHit())
        {
            s.get();
        }
    }
}
 
public class InterThread
{
    public static void main(String args[])
    {
        Shared q = new Shared();
        Producer p = new Producer(q);
        Consumer c = new Consumer(q);
 
        Thread thread1 = new Thread(p, "Producer");
        Thread thread2 = new Thread(c, "Consumer");
 
        thread2.start();
        thread1.start();
 
        //        System.out.println("Press Control-C to stop.");
    }
}    

I expected the output to be:
Producer Put: 0
Consumer Got: 0
Producer Put: 1
Consumer Got: 1
Producer Put: 2
Consumer Got: 2

But, I get the following:
Producer Put: 0
Consumer Got: 0
Producer Put: 1
Consumer Got: 1
Producer Put: 2
Consumer Got: 2
Producer Put: 3
Consumer Got: 3
Consumer Got: 3

Questions:
1. Why does Producer keep puting even though I set the shared variable maxHit to true if the number is > 2, and no assignment is made? (Line 59)
2. Why are there 2 consecutive "Consummer Got: 3" at the end?

Thank you for all your help.

[Campbell Ritchie]

Sounds more complicated than we usually have in beginners'. Moving.

[Campbell Ritchie]

Please don't think wait() and notify() are methods of the Thread class? They are not; they are final methods of the Object class.

And please never say == false or == true, which can lean to subtle errors if you mistakenly write =.

You should write

if (!maxHit && !valueFalse)

or use de Morgan's Law and write

if (!(maxHit || valueFalse))

[ManChun Lam]

I understand that wait() and notify() are methods of Object.

I agree with you on the "==" operators. I have changed my code.

I still cannot figure the results out though. Thanks.

[Steve Luke]

1. Why does Producer keep puting even though I set the shared variable maxHit to true if the number is > 2, and no assignment is made? (Line 59)

The producer only adds once more than you expect. Think of the sequence which occurs:

n = 0
  sharedNumber = 0
  if (sharedNumber > 2) is false
    sharedNumber = 0
    output 0
n = 1
  sharedNumber = 0
  if (sharedNumber > 2) is false
    sharedNumber = 1
    output 1
n = 2
  sharedNumber = 1
  if (sharedNumber > 2) is false
    sharedNumber = 2
    output 2
n = 3
  sharedNumber = 2
  if (sharedNumber > 2) is false
    sharedNumber = 3
    output 3
n = 4
  sharedNumber = 3
  if (sharedNumber > 2) is true
    maxHits = true

So your condition for stopping is wrong if you want it to stop before it reaches 3.

2. Why are there 2 consecutive "Consummer Got: 3" at the end?

When the Consumer is done with getting the 3, the consumer thread maintains possession of the synchronizing lock long enough to get into wait() statement, before the producer has a chance to switch the maxHits flag to true. So the Consumer goes into wait() and the Producer has a chance to get hold of the synchronizing lock, switches maxHits to true, notifies the Consumer it is done, then ends.

The Consumer has a chance to get the synchronized lock again, and since Producer didn't increment sharedNumber it sees the value of 3 and reports it. The Consumer now sees the maxHits is true and the Consumer ends.

The sequence that occurs here is:

(sharedNumber = 2)
Consumer: gains synchronized lock
          outputs 2
          valueSet = false
          notifies Producer
          !maxHits is true
          !(maxHits || valueSet) is true
          wait() and gives up lock
Producer: gains synchronized lock
          (sharedNumber > 2) is false
          sharedNumber = 3
          valueSet = true
          outputs 3
          notifies Consumer
          (i = 4)
          !maxHits is true
          (!maxHits && valueSet) is true
          wait() and gives up lock
Consumer: gains synchronized lock
          outputs 3
          valueSet = false
          notifies Producer
          !maxHits is true
          !(maxHits || valueSet) is true
          wait() and gives up lock
Producer: gains synchronized lock
          (sharedNumber > 2) is true
          maxHits = true
          notifies Consumer
          !maxHits is false
          Producer ends and gives up lock
Consumer: gains synchronized lock
          outputs 3
          valueSet = false
          notifies <noone>
          !maxHits is false
          Thread ends and gives up lock

[Steve Luke]

Originally posted by Steve Luke:

When the Consumer is done with getting the 3, the consumer thread maintains possession of the synchronizing lock long enough to get into wait() statement, before the producer has a chance to switch the maxHits flag to true. ...

That statement isn't exactly true. It does give up the lock when the method comes to an end, but the Consumer thread continues to execute and regains the lock before the Producer Thread is scheduled to run and can try to gain the synchronized lock. The effect in this case is the same, but it wasn't really accurate so I am correcting myself.

[ManChun Lam]

Thank you very much. You step-by-step solution really helps me understand the problem. May I ask you for 1 more favor? How do developers debug multi-threaded code (more than 2)? Tracing by "brain power" is certainly not doable when there are like 5 threads! Thanks again.

[Steve Luke]

Well, the problems that you get with 3,4,5,+ threads are the same ones you get with 2 threads, so it is usually a good idea to start small (like you are doing) to work out the kinks, then build up from there. That makes it easier to work out the events as they happen.

Using a debugging tool with break statements and a profiling tool like VisualVM or JProbe make it easier.