经过实现生产者、消费者再次案例实践Java 多线程

时间 2020-06-29

标签经过实现生产者消费者再次案例实践 java 多线程栏目 Java 繁體版

原文原文链接

线程通讯，在多线程系统中，不一样的线程执行不一样的任务；若是这些任务之间存在联系，那么执行这些任务的线程之间就必须可以通讯，共同协调完成系统任务。java

生产者、消费者案例

案例分析编程

在案例中明，蔬菜基地做为生产者，负责生产蔬菜，并向超市输送生产的蔬菜；消费者经过向超市购买得到蔬菜；超市怎做为生产者和消费者之间的共享资源，都会和超市有联系；蔬菜基地、共享资源、消费者之间的交互流程以下：segmentfault

在这个案例中，为何不设计成生产者直接与给消费者交互？让二者直接交换数据不是更好吗，选择先先把数据存储到共享资源中，而后消费者再从共享资源中取出数据使用，中间多了一个环节不是更麻烦了？安全

其实不是的，设计成这样是有缘由的，由于这样设计很好的体现了面向对象的低耦合的设计理念；经过这样实现的程序能更加符合人的操做理念，更加贴合现实环境；同时，也能很好的避免因生产者与消费者直接交互而致使的操做不安全的问题。网络

咱们来对高耦合和低耦合作一个对比就会很直观了：多线程

高(紧)耦合：生产者与消费者直接交互，生产者（蔬菜基地）把蔬菜直接给到给消费者，双方之间的依赖程度很高；此时，生产者中就必须持有消费者对象的引用，一样的道理，消费者也必需要持有生产者对象的引用；这样，消费者和生产者才可以直接交互。
低(松)耦合： 引入一个中间对象——共享资源来，将生产者、消费者中须要对外输出或者从外数据的操做封装到中间对象中，这样，消费者和生产者将会持有这个中间对象的引用，屏蔽了生产者和消费者直接的数据交互.，大大见减少生产者和消费者之间的依赖程度。

关于高耦合和低耦合的区别，电脑中主机中的集成显卡和独立显卡也是一个很是好的例子。异步

集成显卡广泛都集成于CPU中，因此若是集成显卡出现了问题须要更换，那么会连着CPU一块更换，其维护成本与CPU实际上是同样的；
独立显卡须要插在主板的显卡接口上才能与计算机通讯，其相对于整个计算机系统来讲，是独立的存在，即使出现问题须要更换，也只更换显卡便可。

案例的代码实现

接下来咱们使用多线程技术实现该案例，案例代码以下：ide

蔬菜基地对象，VegetableBase.java性能

// VegetableBase.java

// 蔬菜基地
public class VegetableBase implements Runnable {

    // 超市实例
    private Supermarket supermarket = null;

    public VegetableBase(Supermarket supermarket) {
        this.supermarket = supermarket;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                supermarket.push("黄瓜", 1300);
                System.out.println("push : 黄瓜 " + 1300);
            } else {
                supermarket.push("青菜", 1400);
                System.out.println("push : 青菜 " + 1400);
            }
        }
    }
}

消费者对象，Consumer.javathis

// Consumer.java

// 消费者
public class Consumer implements Runnable {

    // 超市实例
    private Supermarket supermarket = null;

    public Consumer(Supermarket supermarket) {
        this.supermarket = supermarket;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            supermarket.popup();
        }
    }
}

超市对象，Supermarket.java

// Supermarket.java

// 超市
public class Supermarket {

    // 蔬菜名称
    private String name;
    // 蔬菜数量
    private Integer num;

    // 蔬菜基地想超市输送蔬菜
    public void push(String name, Integer num) {
        this.name = name;
        this.num = num;
    }

    // 用户从超市中购买蔬菜
    public void popup() {
        // 为了让效果更明显，在这里模拟网络延迟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        System.out.println("蔬菜：" + this.name + ", " + this.num + "颗。");
    }

}

运行案例，App.java

// 案例应用入口
public class App {

    public static void main(String[] args) {
        // 建立超市实例
        Supermarket supermarket = new Supermarket();
        // 蔬菜基地线程启动, 开始往超市输送蔬菜
        new Thread(new VegetableBase(supermarket)).start();
        new Thread(new VegetableBase(supermarket)).start();
        // 消费者线程启动，消费者开始购买蔬菜
        new Thread(new Consumer(supermarket)).start();
        new Thread(new Consumer(supermarket)).start();
    }

}

发现了问题

运行该案例，打印出运行结果，外表一片祥和，可仍是被敏锐的发现了问题，问题以下所示：

在一片看似祥和的打印结果中，出现了一个很不祥和的特例，生产基地在输送蔬菜时，黄瓜的数量一直都是1300颗，青菜的数量一直是1400颗，可是在消费者消费时却出现了蔬菜名称是黄瓜的，但数量倒是青菜的数量的状况。

之因此出现这样的问题，是由于在本案例共享的资源中，多个线程共同竞争资源时没有使用同步操做，而是异步操做，今儿致使了资源分配紊乱的状况；须要注意的是，并非由于咱们在案例中使用Thread.sleep();模拟网络延迟才致使问题出现，而是原本就存在问题，使用Thread.sleep();只是让问题更加明显。

案例问题的解决

在本案例中须要解决的问题有两个，分别以下：

问题一： 蔬菜名称和数量不匹配的问题。
问题二： 须要保证超市无货时生产，超市有货时才消费。

针对问题一解决方案：保证蔬菜基地在输送蔬菜的过程保持同步，中间不能被其余线程（特别是消费者线程）干扰，打乱输送操做；直至当前线程完成输送后，其余线程才能进入操做，一样的，当有线程进入操做后，其余线程只能在操做外等待。

因此，技术方案可使用同步代码块/同步方法/Lock机制来保持操做的同步性。

针对问题二的解决方案：给超市一个有无货的状态标志，

超市无货时，蔬菜基地输送蔬菜补货，此时生产基地线程可操做；
超市有货时，消费者线程可操做；就是：保证生产基地 ——> 共享资源 ——> 消费者这个整个流程的完整运行。

技术方案：使用线程中的等待和唤醒机制。

同步操做，分为同步代码块和同步方法两种。详情可查看个人另一篇关于多线程的文章：「JAVA」Java 线程不安全分析，同步锁和Lock机制，哪一个解决方案更好

在同步代码块中的同步锁必须选择多个线程共同的资源对象，当前生产者线程在生产数据的时候(先拥有同步锁)，其余线程就在锁池中等待获取锁；当生产者线程执行完同步代码块的时候，就会释放同步锁，其余线程开始抢锁的使用权，抢到后就会拥有该同步锁，执行完成后释放，其余线程再开始抢锁的使用权，依次往复执行。
多个线程只有使用同一个对象（就比如案例中的共享资源对象）的时候，多线程之间才有互斥效果，咱们把这个用来作互斥的对象称之为同步监听对象，又称同步监听器、互斥锁、同步锁，同步锁是一个抽象概念，能够理解为在对象上标记了一把锁。
同步锁对象能够选择任意类型的对象便可，只须要保证多个线程使用的是相同锁对象便可。在任什么时候候，最多只能运行一个线程拥有同步锁。由于只有同步监听锁对象才能调用wait和notify方法，wait和notify方法存在于Object类中。

线程通讯之 wait和notify方法

在 java.lang.Object类 中提供了用于操做线程通讯的方法，详情以下：

wait()：执行该方法的线程对象会释放同步锁，而后JVM把该线程存放到等待池中，等待着其余线程来唤醒该线程；
notify()：执行该方法的线程会唤醒在等待池中处于等待状态的的任意一个线程，把线程转到同步锁池中等待；
notifyAll()：执行该方法的线程会唤醒在等待池中处于等待状态的全部的线程，把这些线程转到同步锁池中等待；

注意：上述方法只能被同步监听锁对象来调用，不然发生 IllegalMonitorStateException。

wait和notify方法应用实例

假设 A线程和B线程共同操做一个X对象(同步锁) ，A、B线程能够经过X对象的wait和notify方法来进行通讯，流程以下：

当A线程执行X对象的同步方法时，A线程持有X对象的锁，B线程没有执行机会，此时的B线程会在X对象的锁池中等待；
当A线程在同步方法中执行X.wait()方法时，A线程会释放X对象的同步锁，而后进入X对象的等待池中；
接着，在X对象的锁池中等待锁的B线程获取X对象的锁，执行X的另外一个同步方法；
当B线程在同步方法中执行X.notify()方法时，JVM会把A线程从X对象的等待池中转到X对象的同步锁池中，等待获取锁的使用权；
当B线程执行完同步方法后，会释放拥有的锁，而后A线程得到锁，继续执行同步方法；

基于上述机制，咱们就可使用同步操做 + wait和notify方法来解决案例中的问题了，从新来实现共享资源——超市对象：

// 超市
public class Supermarket {

    // 蔬菜名称
    private String name;
    // 蔬菜数量
    private Integer num;
      // 超市是否为空
      private Boolean isEmpty = true;

    // 蔬菜基地向超市输送蔬菜
    public synchronized void push(String name, Integer num) {
          try {
              while (!isEmpty) {   // 超市有货时，再也不输送蔬菜，而是要等待消费者获取
                   this.wait();  
             }
                this.name = name;
                this.num = num;
              isEmpty = false;
              this.notify();                 // 唤醒另外一个线程
        } catch(Exception e) {
            
        }
        
    }

    // 用户从超市中购买蔬菜
    public synchronized void popup() {
        
        try {
              while (isEmpty) { // 超市无货时，再也不提供消费，而是要等待蔬菜基地输送
                   this.wait();
            }
              // 为了让效果更明显，在这里模拟网络延迟
            Thread.sleep(1000);
              System.out.println("蔬菜：" + this.name + ", " + this.num + "颗。");
              isEmpty = true;
              this.notify();  // 唤醒另外一线程
        } catch (Exception e) {

        }   
    }
}

线程通讯之使用Lock和Condition接口

因为wait和notify方法，只能被同步监听锁对象来调用，不然发生
IllegalMonitorStateException。从Java 5开始，提供了Lock机制 ，同时还有处理Lock机制的通讯控制的Condition接口。Lock机制没有同步锁的概念，也就没有自动获取锁和自动释放锁的这样的操做了。

由于没有同步锁，因此Lock机制中的线程通讯就不能调用wait和notify方法了；一样的，Java 5 中也提供了解决方案，所以从Java 5开始，能够：

使用Lock机制取代synchronized 代码块和synchronized 方法；
使用Condition接口对象的await、signal、signalAll方法取代Object类中的wait、notify、notifyAll方法；

Lock和Condition接口的性能也比同步操做要高不少，因此这种方式也是咱们推荐使用的方式。

咱们可使用Lock机制和Condition接口方法来解决案例中的问题，从新来实现的共享资源——超市对象，代码以下：

// 超市
public class Supermarket {

    // 蔬菜名称
    private String name;
    // 蔬菜数量
    private Integer num;
      // 超市是否为空
      private Boolean isEmpty = true;
        // lock
        private final Lock lock = new ReentrantLock();
        // Condition
        private Condition condition = lock.newCondition();
        

    // 蔬菜基地向超市输送蔬菜
    public synchronized void push(String name, Integer num) {
          lock.lock(); // 获取锁
          try {
              while (!isEmpty) {   // 超市有货时，再也不输送蔬菜，而是要等待消费者获取
                   condition.await();  
             }
                this.name = name;
                this.num = num;
              isEmpty = false;
              condition.signalAll();                 
        } catch(Exception e) {
            
        } finally {
                lock.unlock();  // 释放锁
        }
        
    }

    // 用户从超市中购买蔬菜
    public synchronized void popup() {
        lock.lock();
        try {
              while (isEmpty) { // 超市无货时，再也不提供消费，而是要等待蔬菜基地输送
                   condition.await();
            }
              // 为了让效果更明显，在这里模拟网络延迟
            Thread.sleep(1000);
              System.out.println("蔬菜：" + this.name + ", " + this.num + "颗。");
              isEmpty = true;
              condition.signalAll();  
        } catch (Exception e) {
                
        }   finally {
                lock.unlock();
        }
    }
}