多线程面试题（二）

题目：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

---

方式一：

package com.example.controller;

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

public class MyContainner<T> {
//    定义一内部容器
    private final LinkedList<T> list = new LinkedList<>();
//    定义容器的最大容量
    private final int MAX_NUM = 10;
//    定义容器元素的实际个数
    private int count;
//    定义消费者方法
    public synchronized T get(){
        T t = null;
        if (0 == list.size()){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = list.removeFirst();
        count--;
//          有瑕疵
        this.notifyAll();
        return t;
    }
//    定义生产者方法
    public synchronized void put(T t){
        while (MAX_NUM == list.size()){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ++count;
        list.add(t);
        this.notifyAll();
    }

    public static void main(String[] args) {
        MyContainner myContainner = new MyContainner();
//        启动两个生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(()->{
                for (int j = 0; j < 25; j++) {
                    myContainner.put(Thread.currentThread().getName()+"--"+j);
                }
            },"P"+i).start();
        }
//        启动十个消费者线程、
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 5; j++) {

                    System.out.println(myContainner.get());
                }
            },"p"+i).start();
        }
    }
}

我们来说一下以上小程序的执行流程，我们创建了一个LinkedList集合用于保存 “馒头”，定义了MAX变量来限制馒头的总数，定义了count变量用来判断生产了几个 “馒头”和消费了几个 “馒头”，在put()方法中，首先判断 LinkedList集合中“馒头”是否是MAX变量的值，如果是启动所有消费者线程，反之开始生产 “馒头”，在get()方法中，首先判断是否还有 “馒头”，也就是list.size()的值是否为0，如果为0通知所有生产者线程开始生产 “馒头”，反之不为0 “馒头”数就继续减少，需要注意的点是，我们为什么要加synchronized，因为++count操作不是原子性的，我们生产了3个 “馒头”，当还没来得及加1的时候，count值为2的时候，另外一个线程读到的值很可能是2，并不是3，所以不加锁就会出问题，我们接着来看main方法中通过for循环分别创建了2个生产者线程生产分别生产25 “馒头”，也就是50个馒头，10个消费者线程每个消费者消费5个 “馒头”，也就是50个 “馒头”，首先启动消费者线程，然后启动生产者线程，至此流程介绍完毕。

我们来分析一下这个小程序

为什么用while而不是用if？ 因为当LinkedList集合中“馒头”数等于最大值的时候，if在判断了集合的大小等于MAX的时候，调用了wait()方法以后，它不会再去判断一次，方法会继续往下运行，假如在你wait()以后，另一个方法又添加了一个“ 馒头”，你没有再次判断，就又添加了一次，造成数据错误，就会出问题，因此必须用while。

注意看我们用的是notifyAll()来唤醒线程的，notifyAll()方法会叫醒等待队列的所有方法，那么我们都知道，用了锁以后就只有一个线程在运行，其他线程都得wait()，不管你有多少个线程，这个时候被叫醒的线程有消费者的线程和生产者的线程，所有的线程都会争抢这把锁，比如说我们是生产者线程，生产满了，满了以后我们叫醒消费者线程，可是很不幸的是，它同样的也会叫醒另外一个生产者线程，假如这个生产者线程拿到了这把锁刚才第一个生产者释放的这把锁，拿到了以后，它又wait()一遍，wait()完以后，又叫醒全部的线程，然后又开始争抢这把锁，其实从这个意义上来讲，生产者的线程wait的你是没有必要去叫醒别的生产者的，我们能不能只叫醒消费者线程，就是生产者线程只叫醒消费者线程，消费者线程只负责叫醒生产者线程，如果想达到这样一个程度的话用方式二。

方式二：

package com.example.controller;

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyContainner2<T> {
//    定义一内部容器
    private final LinkedList<T> list = new LinkedList<>();
//    定义容器的最大容量
    private final int MAX_NUM = 10;
//    定义容器元素的实际个数
    private int count;

    final ReentrantLock lock = new ReentrantLock();
//    已给Condition对象，就可以看做是一个等待队列，以下定义了两个等待队列，consumer一个，provider一个
    Condition consumer = lock.newCondition();
    Condition provider = lock.newCondition();
//    定义消费者方法
    public T get(){
        T t = null;
        try {
            lock.lock();
            if(0 == list.size()){
                consumer.await();
            }
            t = list.removeFirst();
            count--;
            provider.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return t;
    }
//    定义生产者方法
    public void put(T t){
      try {
          lock.lock();
          while(MAX_NUM == list.size()){
              provider.await();
          }
          list.add(t);
          ++count;
          consumer.signalAll();
      }catch (Exception e){
          e.printStackTrace();
      }finally {
          lock.unlock();
      }

    }

    public static void main(String[] args) {
        MyContainner2 myContainner = new MyContainner2();
//        启动两个生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(()->{
                for (int j = 0; j < 25; j++) {
                    myContainner.put(Thread.currentThread().getName()+"--"+j);
                }
            },"P"+i).start();
        }
//        启动十个消费者线程、
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 5; j++) {

                    System.out.println(myContainner.get());
                }
            },"p"+i).start();
        }
    }
}

上面这个小程序用了ReentrantLock，它与synchronized最大区别其实在这个面试题里已经体现出来了，ReentrantLock它可以有两种Condition条件，在put()方法里是我们的生产者线程，生产者线程lock()最后unlock()不多说，一但MAX达到峰值的时候是producer.await()，最后是consumer.signalAll()，就是说我在producer的情况下阻塞的，我叫醒的时候只叫醒consumer，在get()方法里是我们的消费者线程，一但集合的size空了，我是consumer.await()，然后我只叫醒producer，我们来说一下Lock和Condition的本质是什么，它的本质是在synchronized里调用wait()和notify()的时候，它只有一个等待队列，如果lock.newnewCondition()的时候，就变成了多个等待队列，Condition的本质就是等待队列个数，以前只有一个等待队列，现在我new了两个Condition，一个叫producer一个等待队列出来了，另一个叫consumer第二个的等待队列出来了，当我们使用producer.await()的时候，指的是当前线程进入producer的等待队列，使用producer.signalAll()指的是唤醒producer这个等待队列的线程，consumner也是如此，所以上面的小程序就很容易理解了，我在生产者线程里叫醒consumer等待队列的线程也就是消费者线程，在消费者线程里叫醒producer待队列的线程也就是生产者线程，这个小程序的思路就是这样了

两种方式对比：
1、synchronized默认只维护一个等待队列，生产者线程和消费者线程都在这一个等待队列中，notifyAll()会唤醒这一个队列中的所有线程，而不是单纯的只唤醒生产者或者消费者，虽然实现了功能，但是有瑕疵
2、ReentrantLock可以维护多个等待队列，可以有选择的唤醒哪个等待队列中的所有线程，注意是等待队列中的所有线程，而不是哪一个

----------------------本篇博文受马士兵老师启蒙--------------------------------