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\n",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\n",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();

     }
 }