关于Java多线程实现生产者和消费者的问题

在学习Java多线程并发编程的同时，自己写了一个用wait()和notifyAll()实现的生产者消费者相互阻塞，保持同步的程序。
设置产品缓冲区上限为8，可生产者检查counter计数器等于8的时候wait()并没有让多个生产者线程阻塞，而是继续向下执行，对此表示不解，还请诸位高手们给菜鸟弟弟我一个解答，感激不尽！

/*
*   这是一个与多线程有关的以生产者消费者问题为原型的Java程序源码。
*   为了体验notify和notifyAll方法，我尝试开启十个生产者和五个消费者线程，对大小为8的缓冲区进行操作，要做到缓冲区产品达到8的时候，生产者线程阻塞，直到消费者线程减少缓冲区的产品数量，并对阻塞进程进行唤醒。
*   可现在的问题是，当生产者向缓冲区放入8个产品后，wait()方法并没有使生产者线程们停住，对此表示很疑惑。
*
*/



import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class myProducer implements Runnable
{
    private myProAndCon mpc;

    myProducer( myProAndCon mpac ){ this.mpc =  mpac; }

    public void run()
    {
        try {
            while(!Thread.interrupted())
            {
                    //生产者互斥
                    synchronized (this){

                        //静态计数值达到上限，则wait()阻塞，等待被消费者线程唤醒
                        while ( mpc.get() >= 8 )

                        {

                            System.out.println(mpc.get());
                                wait();
                        }
                    }

                    Thread.sleep(100);

                    //未发生阻塞时，向缓冲区内放入产品，增加计数值，并唤醒所有阻塞的消费者线程
                    synchronized ( mpc.c ){
                            System.out.println("[ P ] The number is " + mpc.inc() );
                            mpc.c.notifyAll();
                    }
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


class myConsumer implements Runnable
{
    private myProAndCon mpc;

    myConsumer( myProAndCon mpac ){ this.mpc =  mpac; }

    public void run()
    {
        try {
            while(!Thread.interrupted())
            {
                //消费者互斥
                synchronized ( this )
                {
                    //当缓冲区无产品时，消费者线程阻塞，等待被生产者线程唤醒
                    while ( mpc.get() <= 0 )
                        wait();
                }

                Thread.sleep(3000);

                //未发生阻塞时，从缓冲区取出产品，减少计数值，并唤醒所有阻塞的生产者线程
                synchronized (mpc.p){
                        System.out.println("[ C ] The number is " + mpc.dec() );
                        mpc.p.notifyAll();
                }


            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}




public class myProAndCon {
    //public final int S = 8;

    //缓冲区计数器(静态)以及对其进行的三个synchronized操作
    volatile private static int  counter = 0;

    synchronized static int inc(){ return ++ counter; }
    synchronized static int dec(){ return  counter -= 2; }
    synchronized static int get(){ return  counter; }

    //构造两个对象，作为开启线程的参数
    public myConsumer c = new myConsumer(this);
    public myProducer p = new myProducer(this);

    private ExecutorService exec = Executors.newCachedThreadPool();

    public myProAndCon(){

        //打开十个生产者线程
        for ( int i  = 0 ; i < 10 ; i ++ )
            exec.execute(p);

        //打开五个消费者线程
        for  ( int i = 0 ; i < 5 ; i ++ )
            exec.execute(c);

    }


    //主函数调用myProAndCon类构造方法，开始执行各个线程
    public static void main(String[] s)
    {
        new myProAndCon();
    }


}