阻塞队列（三）—— LinkedBlockingDeque源码

标题LinkedBlockingDeque源码

简介

LinkedBlockingDeque是一个双端队列，可以消费队头以及队尾的元素，我们可以设定最大容量，但是设定好后不可改变，因为被final修饰了，然后没有设置的话默认是Integer的最大值，只有一把锁和两个条件队列
下面来看看源码

源码

首先是重要内部类

	//Node节点
    static final class Node<E> {
        //元素value
        E item;

        //前继节点
        Node<E> prev;

        //后继节点
        Node<E> next;

        //
        Node(E x) {
            item = x;
        }
    }

看到Node的内部结构，就可以很容易看出这是一个双端队列
然后来看看他的重要的属性

重要属性

	//头节点
    transient Node<E> first;

    //尾节点
    transient Node<E> last;

    //个数
    private transient int count;

    //容量
    private final int capacity;

    //只有一把锁，说明不能同时进行队头和队尾的插入
    final ReentrantLock lock = new ReentrantLock();

    //队列为空，不能消费的阻塞队列
    private final Condition notEmpty = lock.newCondition();

    //队列满了，不能继续添加的阻塞队列
    private final Condition notFull = lock.newCondition();

然后是构造函数

构造函数

	//默认是Integer的最大值
	public LinkedBlockingDeque() {
        this(Integer.MAX_VALUE);
    }

	//可选容量
    public LinkedBlockingDeque(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
    }


    public LinkedBlockingDeque(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock lock = this.lock;
        lock.lock(); // Never contended, but necessary for visibility
        try {
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (!linkLast(new Node<E>(e)))
                    throw new IllegalStateException("Deque full");
            }
        } finally {
            lock.unlock();
        }
    }

然后是常用的方法

常用方法

在头部添加元素

	public void addFirst(E e) {
        if (!offerFirst(e))
            throw new IllegalStateException("Deque full");
    }
	
	public boolean offerFirst(E e) {
        if (e == null) throw new NullPointerException();
        //构建节点
        Node<E> node = new Node<E>(e);
        //加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return linkFirst(node);
        } finally {
            lock.unlock();
        }
    }

	/* **
     * 在头部添加
     */
    private boolean linkFirst(Node<E> node) {
        //如果队列容量满了
        if (count >= capacity)
            return false;
        //获取到头节点
        Node<E> f = first;
        node.next = f;
        //修改头节点
        first = node;
        //判断尾节点是不是空，是的话就会将他置为新的尾节点
        if (last == null)
            last = node;
        else
            f.prev = node;
        ++count;
        //因为插入了，所以通知消费者来进行消费，
        notEmpty.signal();
        return true;
    }

在尾部添加元素

	/* **
     * 在尾节点进行添加
     * 基本和上面的一样
     */
    private boolean linkLast(Node<E> node) {
        //如果超出容量，
        if (count >= capacity)
            return false;
        //获取到尾节点
        Node<E> l = last;
        //设置前继节点
        node.prev = l;
        //更新尾节点
        last = node;
        //修改首部
        if (first == null)
            first = node;
        else
            l.next = node;
        //数量++
        ++count;
        //通知因为没有元素可消费而等待的线程
        notEmpty.signal();
        return true;
    }

消费头节点元素

	/* **
     * 消费头节点
     */
    private E unlinkFirst() {
        //获取到头节点
        Node<E> f = first;
        //如果头是空的，返回空
        if (f == null)
            return null;
        //获取到头节点的下一个节点
        Node<E> n = f.next;
        //获取到头节点的元素
        E item = f.item;
        //帮助GC
        f.item = null;
        f.next = f; // help GC
        //更新头节点
        first = n;
        //判断尾节点
        if (n == null)
            last = null;
        else
            //修改前继为空，因为他的前继就是原来的头节点，但是已经被取出来了
            n.prev = null;
        --count;
        //因为消费了，所以可以继续唤醒插入线程
        notFull.signal();
        return item;
    }

消费尾节点

    /* **
     * 消费尾节点
     */
    private E unlinkLast() {
        //获取到尾节点，
        Node<E> l = last;
        //如果尾节点是空的
        if (l == null)
            return null;

        //获取到尾节点的前继
        Node<E> p = l.prev;
        //获取到值
        E item = l.item;
        //帮助GC
        l.item = null;
        l.prev = l; // help GC
        //更新尾节点
        last = p;
        //判断是不是头节点
        if (p == null)
            first = null;
        else
            p.next = null;
        --count;
        //通知节点
        notFull.signal();
        return item;
    }

因为我们的消费或者添加元素的时候，都需要加锁，所以基本操作和双端队列的基本一致，但是只是多了一个唤醒操作

然后为什么我们的LinkedBlockingDeque只有一把锁，但是我们的LinkedBlockingQueue却有两把呢？
来举个例子
现在是没有数据，当A线程去获取一个头元素，B线程去获取一个尾元素，因为没有元素，所以两个都被阻塞了，然后C线程调用了我们的插入尾元素，然后想要去唤醒其他的线程，问题来了，如果需要唤醒线程，那么其他两个的锁我们需要到，我们要获得两把锁，和一把锁的作用其实是一样的，并且两把锁的开销要大于1把锁，所以这里只设置了一把锁，反之亦然