JAVA多线程中生产者与消费者问题中synchronized方法中为什么用while而不用if~~~

Question

代码如下:
class ProduceInteger extends Thread
{
    private HoldInteger sharedObject;
    public ProduceInteger(HoldInteger shared)
    {
        sharedObject=shared;
    }
    
    public void run()
    {
        for(int count=1;count<8;count++)
        {
            try
            {
                Thread.sleep(((int)Math.random()*3000));
                sharedObject.setSharedInt(count);
            }
            catch(InterruptedException exception)
            {
            }
            System.out.println("Producer #"+count+"done producing, put: "+count);
        }
    }
}class ConsumeInteger extends Thread
{
    private HoldInteger sharedObject;
    public ConsumeInteger(HoldInteger shared)
    {
        sharedObject=shared;
    }
    
    public void run()
    {
        int value=0;
       for(int i=1;i<8;i++)
       {
           try
            {
                Thread.sleep(((int)Math.random()*3000));
                value=sharedObject.getSharedInt();
            }
            catch(InterruptedException exception)
            {
            }
           System.out.println("Consumer #"+i+"done consuming, got: "+value);
       }
    }
    
}class HoldInteger
{
    private int sharedInt=-1;
    boolean available=false;    public synchronized void setSharedInt(int value)
    {
        while(available==true)
        {
            try
            {
                System.out.println("Producer tries to wite,Buffer is full.Wait");
                wait();
            }
            catch(InterruptedException e)
            {
            }
        }
        sharedInt=value;
        available=true;
        notifyAll();
    }
    public synchronized int getSharedInt()
    {
       while(available==false)
        {
            try
            {
                System.out.println("Consumer tries to read,Buffer is empty.Wait");
                wait();
            }
            catch(InterruptedException e)
            {
            }
        }
        available=false;
        notifyAll();
        System.out.println("实验");
        return sharedInt;
    }
}public class ProdAndCons {
   
    public static void main(String[] args) {
        HoldInteger sharedObject=new HoldInteger();
        ProduceInteger producer=new ProduceInteger(sharedObject);
        ConsumeInteger consumer=new ConsumeInteger(sharedObject);
        producer.start();
        consumer.start();
   
    }
    
}就是红色黑体部分~~~为什么不用if,如果用了可能会出现什么情况...

Answer 1

 因为当满的时候，线程1 setSharedInt方法执行wait()后进入对象等待池，并且释放对象锁，此时如果又有个线程2得到锁进入 setSharedInt方法 也执行wait()方法，进入对象的等待池并且释放锁；线程3得到锁后执行 getSharedInt方法，使得满不成立，并且执行notifyAll()，将线程1，2从等待池中放入锁池等锁，有可能线程1得到锁后继续执行 setSharedInt
这样生产了一个元素，而当线程1执行完后，恰恰又是线程2得到锁，他得到锁后也继续执行setSharedInt，也生产了一个元素，这样就超出了容量，如果是while的话，再让他判断一次的话，线程2不满足条件，继续进入对待池 这就是用while而不使用if的原因

Answer 2

在这个程序中应该只有两个线程啊,而且出现了这样的结果是什么原因呢,不是当setSharedInt后就会覆盖value么,为什么两次put后还能取到前面一次put的值?谢谢楼上的
Producer #1done producing, put: 1
实验
Consumer #1done consuming, got: 1
Producer #2done producing, put: 2
实验
Consumer #2done consuming, got: 2
Producer #3done producing, put: 3
实验
Consumer #3done consuming, got: 3
Producer #4done producing, put: 4
Producer tries to wite,Buffer is full.Wait
实验
Producer #5done producing, put: 5
Consumer #4done consuming, got: 4
Producer tries to wite,Buffer is full.Wait
实验
Producer #6done producing, put: 6
Consumer #5done consuming, got: 5
Producer tries to wite,Buffer is full.Wait
实验
Producer #7done producing, put: 7
Consumer #6done consuming, got: 6
实验
Consumer #7done consuming, got: 7

Answer 3

我用p,v操作来解释吧main()
{
mutext=1;
full=m;  有M个可用资源
empty=0;
cobain
   product();
   consumer();
coend
}product()
{
while(还有可用资源)
{
 p(full);
 p(mutex);
 生产一个产品
 v(mutex);
 v(empty);
}
}consumer()
{
while(还有产品)
{
p(empty);
p(mutex);
消费一个产品
v(mutex);
v(full);
}
}

Answer 4

因是竟争资源的不只一个线程,被唤醒后,不一定可以获得资源并返回,所以要用while,也就是没有拿到资源决不返回