结合生活，剖析《生产者消费者模型》-java多线程（一）

　　博客园的园友们好，看博客园上各位大佬的文章，已陪伴了我程序员职业的三年，

如今自己同样希望能把自己从小白到菜鸟的成长过程分享给大家。不定期更新！！！

首先我本人智商不高，理解问题十分吃力，完全不属于天才的行列，因此学习每一个知识

都喜欢刨根问底，结合生活，彻彻底底理解知识的本质！

进入正题，这篇文章，主要站在一个初学者的角度，结合经典的“生产者消费者模型”，写一个java多线程例子！

首先解释几个概念：

　　1、#进程：通俗的讲，就是一个程序一次执行的过程。是系统进行资源分配和调度的一个独立单位。

　　2、#线程：一个进程的生命周期，由一个或若干个线程完成。是CPU调度和分派的基本单位。

　　3、#并行：同一时间点或者时间段，可以处理超过一个任务的能力。

　　eg:你正在lol，女朋友来电话，于是你单手操作或者侧头夹住手机，既聊天又打团，这就是你自己并行处理了，

撩妹和打游戏。这个过程，你就类似于cpu，前提你是多核。

　　4、#并发：主要针对多线程提出的概念。可以在一个时间段，交替执行不同事情的能力。

　　eg:你正在lol，女朋友来电话，于是你挂机去接电话，然后打完电话回来面对腾讯的裁决。或者你等着打完团，然后

面对女友的生气。这就是并发，你交替执行了不同事情。这个过程，你也类似于cpu，可以不用多核。

二、简单代码实现多线程

　　2.1模型图

注释：张全蛋经过自己的努力，进入富士康工厂工作，主要负责生产时下流行的iPhoneXs，然后广大果粉在库存充足的情况下购买iPhoneXs。

这个过程共涉及以下角色和过程：

　　1、生产者（张全蛋）。

　　2、消费者（广大果粉）。

　　3、产品（iPhoneXs）。

　　4、生产产品，购买产品。

2.2 程序展示

　　2.2.1  产品类

由于我们此次实验过程，主要涉及生产产品，所以我们可以忽略产品本身具有的属性和方法。

 package com.dcits.weipt;

 /**
  * 产品实体类
  * 因我们此次实验是针对生产产品
  * 所以我们忽略产品本身所具有的方法和属性
  * @author weipt
  * @date 20180915*/
 public class Product {

 }

　　2.2.2 工厂类

工厂类用于生产产品，需要注意的是，在java中，生产一个产品，就是new一个产品类的实体对象。

 package com.dcits.weipt;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * 生产产品的工厂类
  * 生产一个产品则意味着new一个产品对象
  * 消费一个产品则意味着remove一个对象
  * @author weipt
  * @date 20180915*/

 public class ProductFactory {
     private List<Product> list = new ArrayList<Product>();  //利用list保存对象

     /**
      * 工厂生产产品的方法
      * 单位时间生产3个
      * */
     public void makeProduct() {
         for(int i=0;i<3;i++) {
             list.add(new Product());
         }
     }

     /**
      * 工厂消费产品的方法
      * 单位时间消费1个*/
     public void moveProduct() {
         list.remove(0);
     }

     /**
      * 获取产品个数*/
     public int getNum() {
         return list.size();
     }

 }

　　2.2.3 生产者

用于不断调用工厂类，生产产品。每当我们生产一次产品，需要调用notify/notifyAll通知或唤醒消费者来购买。

但当我们生产超过max，需要调用wait，等待消费者购买，减少库存。

 package com.dcits.weipt;

 /**
  *生产者实体类
  * @author weipt
  * @date 20180915*/

 public class Producer implements Runnable {
     private final int MAX_PRODUCT = 30;
     private ProductFactory pf;

     public Producer(ProductFactory pfIn) {
         this.pf = pfIn;
     }

     @Override
     public void run() {
         produce();
     }

     /**
      * 生产者生产，产品
      */
     public void produce() {
         while (true) {
             synchronized (pf) {
                 if (pf.getNum() >= MAX_PRODUCT) {
                     try {
                         System.out.println("warnning! 库存已满，请稍微再生产！");
                         pf.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }else {
                     pf.makeProduct();
                     System.out.println("P---》生产者生产了第【" + pf.getNum() + "】个产品");
                     pf.notifyAll();
                 }
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }
     }
 }

　　2.2.4 消费者

用于不断调用工厂类，购买产品。每当我们购买一次产品，需要调用notify/notifyAll通知或唤醒生产者去生产。

但当库存小于min，需要调用wait，等待生产者，增加库存。

 package com.dcits.weipt;

 /**
  * 消费者实体类
  * @author weipt
  * @date 20180915*/

 public class Consumer implements Runnable {
     private final int MIN_PRODUCT = 0;   //产品最小值
     private ProductFactory pf;           //产品工厂对象

     /**
      * 通过构造方法获取产品对象*/
     public Consumer(ProductFactory pfIn) {
         this.pf = pfIn;
     }

     @Override
     public void run() {
         consume();
     }

     /**
      * 消费者从库存中取产品
      */
     public void consume() {
         while (true) {
             synchronized (pf) {           //因为生产者和消费者都是对产品操作，所以对产品进行加锁
                 if (pf.getNum() <= MIN_PRODUCT) {
                     try {
                         System.out.println("warnning! 库存已空，请稍微再取！");//注意顺序，要放到wait之前
                         pf.wait();                            //等待其他线程操作，直到收到其他线程的notify
                         //此处我没有写notify，因为库存缺货，就只能等生产者生产，唤醒其他消费者没有用
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }else {
                     System.out.println("C---》消费者取走了第【" + pf.getNum() + "】个产品");
                     pf.moveProduct();   //产品出库
                     pf.notifyAll();    //通知生产者可以继续生产
                 }
                 try {
                     Thread.sleep(1000);   //防止日志打印过多，没有可观性
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }
     }

 }

　　2.2.5 开始工作

在main方法中，开启消费者和生产者线程。

 package com.dcits.weipt;

 /**
  * 公司领导
  * 用于让整个系统运作起来*/

 public class HelloThread{
     public static void main(String[] args) {
         ProductFactory pf = new ProductFactory();
         Producer p = new Producer(pf);
         Consumer c = new Consumer(pf);
         Thread pt = new Thread(p);
         Thread ct = new Thread(c);
         pt.start();   //我们可以开启多个消费者或者多个生产者
         ct.start();
     }
 }

到这里，这篇文章就彻底结束了。

注：如需索要编译好的项目源码可关注公众号mht18391859179（扫描下方二维码），回复：  免费领取

如果需要交流或者指正，可通过上述公众号，或者email：wpt191@163.com与本人联系。

笨鸟先飞，终生学习

特别鸣谢：

　　1、感谢胡**，同志的交流与指导。

　　2、感谢博客园，csdn，知乎等大牛文章的启迪。