多线程--生产者消费者问题

package producerConsumer;

/**
 * <生产者，消费者>
 * 
 * @author snowday88
 */
public class ProducerConsumer
{
    
    public static void main(String[] args)
    {
        SynStatck ss = new SynStatck();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);
        new Thread(p).start();
        new Thread(c).start();
    }
}

// 假设生产面包

class Bread
{
    int id;
    
    public Bread(int id)
    {
        this.id = id;
    }
    
    public String toString()
    {
        return "bread -" + id;
    }
}

// 放面包的筐
class SynStatck
{
    Bread[] breads = new Bread[6];
    
    int index = 0;
    
    public synchronized void push(Bread bread)
    {
        while (index == breads.length)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        this.notify();
        breads[index++] = bread;
        System.out.println("生产了：" + bread);
    }
    
    public synchronized Bread pop()
    {
        while (index == 0)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        System.out.println("消耗了：" + breads[index]);
        return breads[index];
    }
}

// 生产者
class Producer implements Runnable
{
    int num = 0;
    
    SynStatck synStack;
    
    public Producer(SynStatck stack)
    {
        this.synStack = stack;
    }
    
    public void run()
    {
        // 一次生产20个
        for (int i = 0; i < 20; i++)
        {
            Bread bread = new Bread(num++);
            synStack.push(bread);
            try
            {
                Thread.sleep(1);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

// 消费者
class Consumer implements Runnable
{
    SynStatck synStack;
    
    public Consumer(SynStatck stack)
    {
        this.synStack = stack;
    }
    
    public void run()
    {
        for (int i = 0; i < 20; i++)
        {
            synStack.pop();
            try
            {
                Thread.sleep(1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

这里有一个隐藏的问题：为什么使用while而不使用if呢？

因为如果当index等于最大或者最小的时候，而且此时一个线程执行到wait，且此时被打断了，则会跳出if，而while则不会跳出，会继续检查条件是否满足。