ArrayBlockingQueue和LinkedBlockingQueue的区别

1.    队列中锁的实现不同
       ArrayBlockingQueue实现的队列中的锁是没有分离的，即生产和消费用的是同一个锁；
       LinkedBlockingQueue实现的队列中的锁是分离的，即生产用的是putLock，消费是takeLock
   
2.    在生产或消费时操作不同
       ArrayBlockingQueue实现的队列中在生产和消费的时候，是直接将枚举对象插入或移除的；
       LinkedBlockingQueue实现的队列中在生产和消费的时候，需要把枚举对象转换为Node<E>进行插入或移除，会影响性能

3.    队列大小初始化方式不同
       ArrayBlockingQueue实现的队列中必须指定队列的大小；
       LinkedBlockingQueue实现的队列中可以不指定队列的大小，但是默认是Integer.MAX_VALUE
   
注意:
1.     在使用LinkedBlockingQueue时，若用默认大小且当生产速度大于消费速度时候，有可能会内存溢出
2.    在使用ArrayBlockingQueue和LinkedBlockingQueue分别对1000000个简单字符做入队操作时，
       LinkedBlockingQueue的消耗是ArrayBlockingQueue消耗的10倍左右，

       即LinkedBlockingQueue消耗在1500毫秒左右，而ArrayBlockingQueue只需150毫秒左右。

ArrayBlockingQueue

 final ReentrantLock lock;

LinkedBlockingQueue

/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();
/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();

public class BlockingQueueLC<T> {
    private List queue = new LinkedList<>();
    private final int limit;
    Lock lock = new ReentrantLock();
    private Condition needNotEmpty = lock.newCondition();//不为空
    private Condition needNotFull = lock.newCondition();//不为满


    public BlockingQueueLC(int limit) {
        this.limit = limit;
    }

    public void enqueue(T item) throws InterruptedException {
        lock.lock();
        try{
            while(this.queue.size()==this.limit){
                needNotFull.await();//1
            }
            this.queue.add(item);
            needNotEmpty.signal();//2
        }finally{
            lock.unlock();
        }
    }

    public  T dequeue() throws InterruptedException {
        lock.lock();
        try{
            while(this.queue.size()==0){
                needNotEmpty.await();//2
            }
            needNotFull.signal();//1
            return (T) this.queue.remove(0);
        }finally{
            lock.unlock();
        }
    }
}

生产者消费者

package com.dongnaoedu;

/**
 * Created by BF100 on 2018/1/30.
 */

import java.lang.Thread;

public class MyProducerComsumer {
    private MyBlockingQueue queue = new MyBlockingQueue(3);
//    private BlockingQueue queue = new LinkedBlockingDeque(3);

    class Car {
        private String name;
        private String price;

        public Car(String name, String price) {
            this.name = name;
            this.price = price;
        }
    }

    class Producer extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Car car = new Car("宝马", "888888");
                    queue.put(car);
                    System.err.println("生产者生产====" + car.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Comsumer extends Thread {
        @Override
        public void run() {
            while (true) {
//                try {
                Car car = (Car) queue.take();
                System.err.println("消费者购买汽车" + car.toString());
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
            }
        }
    }

    public static void main(String[] args) {
        MyProducerComsumer myProducerComsumer = new MyProducerComsumer();
        Producer producer1 = myProducerComsumer.new Producer();
        Producer producer2 = myProducerComsumer.new Producer();
        Comsumer comsumer = myProducerComsumer.new Comsumer();
        producer1.start();
        producer2.start();
        comsumer.start();
    }

}