Java Concurrent:An issue of producers and consumers

Question

The first is my understanding:

notify() only will wake one thread. The awakened thread will continue from wait().

 public class T_SynList extends LinkedList<Item>{
    public static int MAX=5;
    public synchronized void produce(String producer)
    {
        while(size()==MAX)
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        add(new Item(producer,0));
        notify();
    }

    public synchronized Item consume(String consumer)
    {
        //**My doubt!!!!!!!!**
        while(size()==0)
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Item item=removeFirst();
        item.setConsumer(consumer);
        notify();
        return item;
    }
}

There are 1 producers and 5 consumers. If I change while(size()==0) to if(size()==0), the procedure will get error(removeFirst() from a list with size=0).

The reason may be wake up two consumer threads at the same time but only one can continue. But document said that notify() only wake one thread. Why can't I do such changes?

Answer 1

The while(size() == 0) is im portant. If the consumer is woken up, he checks for himself if there is a element to consume. If not, he goes back to sleep.

The notify() method will wake up ONE thread on the same monitor ('this' in your case). It's possible that the finished consumer wakes up another consumer after taking the last element.
If you use if(size()==0) the other consumer is woken up, tries to take an element and rises an error.

You have to also use a notfyAll() to wake up all threads, the fastest takes the element and all others will go back to sleep. If not, it's possible that you got stock in a deadlock.

p1 -> put element -> notify c1 -> sleep 
c1 -> take element -> notify c2 -> sleep
c2 -> no element -> sleep -> not waking up anyone -> deadlock