写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。
1、synchronized同步方法
public class Container1<T> {final private LinkedList<T> lists = new LinkedList<>();final private int MAX = 10; //最多10个元素private int count = 0;//生产者public synchronized void put(T t) {while(lists.size() == MAX) {//使用while不断判断是否等于MAX值，当数量达到MAX值后使得生产线程阻塞，被消费一个便立刻结束循环唤醒生产线程try {this.wait(); //effective java} catch (InterruptedException e) {e.printStackTrace();}}lists.add(t);++count;this.notifyAll(); //֪ͨ通知消费者线程进行消费}//消费者public synchronized T get() {T t = null;while(lists.size() == 0) {//一旦数量等于0，便使消费线程阻塞try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}t = lists.removeFirst();count --;this.notifyAll(); //通知生产者线程进行生产return t;}public static void main(String[] args) {Container1<String> c = new Container1<>();//启动消费者线程for(int i=0; i<10; i++) {new Thread(()->{for(int j=0; j<5; j++) System.out.println(c.get());}, "c" + i).start();}try {Thread.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}//启动生产者线程for(int i=0; i<2; i++) {new Thread(()->{for(int j=0; j<25; j++) c.put(Thread.currentThread().getName() + " " + j);}, "p" + i).start();}}}
程序中定义了MAX变量来限制产品的总数，定义了count变量用来判断生产了几个 产品和消费了几个 产品，在put()方法中，首先判断 LinkedList集合中产品是否是MAX变量的值，如果是启动所有消费者线程，反之开始生产 产品，在get()方法中，首先判断是否还有 产品，也就是MAX的值是否为0，如果为0通知所有生产者线程开始生产 产品，反之不为0 产品数就继续减少，需要注意的点是，这里我们加了synchronized，因为++count生产产品变成新值时，一个线程还没来得及加的时候，咋们的count还为老值，另外一个线程读到的值很可能还不是最新值，所以不加锁就会出问题，main方法中通过for循环分别创建了2个生产者线程生产分别生产25个 产品，也就是50个产品，10个消费者线程每个消费者消费5个 产品，也就是50个 产品，首先启动消费者线程，然后启动生产者线程。
在判断容器中为空或者满的时候为什么用while而不是用if？ 因为当LinkedList集合中产品数等于最大值的时，if在判断了集合的大小等于MAX的时候，调用了wait()方法以后，它不会再去判断一次，方法会继续往下运行，假如在你wait()以后，另一个方法又添加了一个产品，你没有再次判断，就又添加了一次，造成数据错误，就会出问题，因此必须用while。
注意看我们用的是notifyAll()来唤醒线程的，notifyAll()方法会叫醒等待队列的所有方法，那么我们都知道，用了锁以后就只有一个线程在运行，其他线程都得wait()，不管你有多少个线程，这个时候被叫醒的线程有消费者的线程和生产者的线程，所有的线程都会争抢这把锁，比如说我们是生产者线程，生产满了，满了以后我们叫醒消费者线程，可是很不幸的是，它同样的也会叫醒另外一个生产者线程，假如这个生产者线程拿到了刚才第一个生产者释放的这把锁，它又wait()一遍，wait()完以后，又叫醒全部的线程，然后又开始争抢这把锁，其实从这个意义上来讲，生产者的线程wait时，没有必要去叫醒别的生产者。
所以基于这样的考虑，我们生产者只叫醒消费者线程，消费者线程只负责叫醒生产者线程。
2、ReentrantLock锁
public class Container2<T> {final private LinkedList<T> lists = new LinkedList<>();final private int MAX = 10; //最多10个元素private int count = 0;private Lock lock = new ReentrantLock();//两个Condition，即两个同步队列private Condition producer = lock.newCondition();private Condition consumer = lock.newCondition();public void put(T t) {try {lock.lock();while(lists.size() == MAX) {producer.await();}lists.add(t);++count;consumer.signalAll(); //通知消费者线程进行消费} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}}public T get() {T t = null;try {lock.lock();while(lists.size() == 0) {consumer.await();}t = lists.removeFirst();count --;producer.signalAll(); //通知生产者进行生产} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}return t;}public static void main(String[] args) {Container2<String> c = new Container2<>();//启动消费者线程for(int i=0; i<10; i++) {new Thread(()->{for(int j=0; j<5; j++) System.out.println(c.get());}, "c" + i).start();}try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}//启动生产者线程for(int i=0; i<2; i++) {new Thread(()->{for(int j=0; j<25; j++) c.put(Thread.currentThread().getName() + " " + j);}, "p" + i).start();}}}
使用ReentrantLock与synchronized最大区别在于ReentrantLock它可以有两种Condition条件，即会有两个同步队列，一个是成产线程的同步队列，一个是消费者的同步队列，一但数量达到MAX峰值的时候调用producer.await()，使得生产线程全部阻塞，调用consumer.signalAll()唤醒全部消费者线程，也就是说我在producer的情况下阻塞的，我叫醒的只是consumer，同理在消费者线程使得数量为0的时候，我阻塞的全是消费者线程，叫醒的全是生产者线程，这就是ReentrantLock的含义，它能够精确的指定哪些线程被叫醒，我们来说一下Lock和Condition的本质是什么，在synchronized里调用wait()和notify()的时候，它只有一个等待队列，而lock.newnewCondition()的时候，有多少个Condition，则创建了多少个等待队列，Condition的本质就是等待队列个数，以前只有一个等待队列，现在我new了两个Condition，一个叫producer等待队列，另一个叫consumer的等待队列，当我们使用producer.await();的时候，指的是阻塞producer的等待队列中的线程，使用producer.signalAll()指的是唤醒producer这个等待队列的线程，consumner也是如此，在生产者线程里叫醒consumer等待队列的线程也就是消费者线程，在消费者线程里叫醒producer待队列的线程也就是生产者线程。
