Java实现生产与消费(完美注释版)

/**
 * 2019年8月8日17:42:23
 * 目的：Java多线程实现生产与消费
 * @author 张涛
 *
 *    多态：
 *        一个父类的引用既可以指向父类对象
 *        也可以指向子类对象
 *        它会根据当前时刻指向的不同
 *        自动调用该对象里面的属性和方法
 *
 *    this:
 *        this在构造方法中表示正在构造的对象
 *        this在一般方法中表示正在调用的对象
 */

//构建栈(杯子)类
class synstack
{
    //数组相当于货架，每次只能放入6个
    char[] data = new char[6];
    
    //数组当前有效元素个数
    int cnt = 0;
    
    //生产方法
    public synchronized void push(char ch)
    {
        //每一次都要判断货架是否满了，如果满了，就wait，唤醒另一个进程
        while(cnt == data.length)
        {
            //异常处理,wait属于必须要捕获的异常
            try
            {
                this.wait();
            }
            catch(Exception e)
            {
                //可以不做任何处理
            }
        }
        //唤醒另一个进程
        this.notify();
        
        //讲数据以压栈的方式存入货架
        data[cnt] = ch;
        
        //有效个数自增
        cnt++;
        
        System.out.printf("第%d个产品已经生产好，该产品为%c
",cnt,ch);
    }
    
    //消费方法
    public synchronized char pop()
    {
        //定义货物
        char ch = 0;
        
        //每一次都要检查是否已经把杯子里的货物消费完
        //如果消费完了，则进入等待状态，唤醒另一个进程
        while(cnt == 0)
        {
            //wait属于必须要捕获的异常
            try
            {
                this.wait();
            }
            catch(Exception e)
            {
                //可以不做任何处理
            }
        }
        
        //唤醒另一个进程
        this.notify();
        
        //把货物消费掉
        cnt--;
        ch = data[cnt];
        System.out.printf("正在消费掉第%d个货物，该货物为%c
",cnt+1,ch);
        return ch;
    }
}

//生产类
class producer implements Runnable
{
    //定义父类的引用，私有的原因是不想任意修改父类引用的指向
    public synstack ss = null;
    
    //构造方法，通过多态实现指向的不同，从而达到调用内部方法的作用
    public producer(synstack ss)
    {
        this.ss = ss;
    }
    
    //重写run方法，以用来实现输入
    public void run()
    {
        char ch = 0;
        for(int i=0; i<26; i++)
        {
            ch =(char) ('a' + i);
            ss.push(ch);
            /*
             * 我当时代码写到这一步遇到的问题
             * 目前问题是无法调用push方法,只能通过多态的方式解决
            */
            
        }
    }
}

//消费类
class consumer implements Runnable
{
    //定义父类的引用，私有的原因是不想任意修改父类引用的指向
    private synstack ss = null;
    
    //构造方法，通过多态的实现父类引用指向的不同，从而达到调用内部方法的作用
    public consumer(synstack ss)
    {
        //this出现在构造方法中时表示正在构造的对象
        this.ss = ss;  
    }
    //重写run方法，实现输出
    public void run()
    {
        //刻意得减慢消费的速度
        for(int i=0; i<26; i++)
        {
            //sleep属于必须要捕获的异常
            try
            {
                Thread.sleep(1000);
            }
            catch(Exception e)
            {
                
            }
            
            //开始调用消费
            ss.pop();
        }
        
        
    }
}


public class Pc
{
    public static void main(String[] args)
    {
        //构造出杯子对象
        synstack ss = new synstack();
        
        //构建出生产对象
        producer p = new producer(ss);
        
        //构建出消费对象
        consumer c = new consumer(ss); 
        
        //创建线程，第二种方式
        Thread t1 = new Thread (p);
        Thread t2 = new Thread (c);
        
        //开启线程
        t1.start();
        t2.start();
        
    }
}