java进阶|LinkedBlockingQueue源码分析

现在是2020/05/18:23:12分，是的，马上就要到凌晨了，然而我才开始写这篇文章，为什么这么晚写这篇文章，不困吗，或许是，或许不是，其实在我刷完抖音之后脑海里想的就是分析一下LinkedBlockingQueue的源码吧，至于为什么要这么晚还去分析，有这个必要吗，或许是自己喜欢这个点有点久了。

一般你们遇到的每一篇文章都是经过我最少一个周之前想写的内容，所以文章出现的时候，我自己在心里也沉淀了很久才发出来，这样就会比较对自己友好一点。

是的，是人都会有私心，我喜欢分享，但我不会将很私密的事情去分享，因为互联网上什么人都有，没有必要将自己喜欢的东西分享出来，文章只会分享一些技术相关的内容和自己思考的一些事情，所以你看到的内容也就是我喜欢分享的内容，好了，闲扯就不说了，接下来我要开始分析LinkedBlockingQueue了。

按照自己的风格，接下来先看下LinkedBlockingQueue的继承接口和实现接口吧。

public class LinkedBlockingQueue<E> extends AbstractQueue<E>        implements BlockingQueue<E>, java.io.Serializable {}

java中的继承，封装，多态都在源码里面体现的比较友好，所以这里就不过多介绍了，想了解这些内容的可以去搜索了解一下，一般我们创建一个容器都是从new关键字开始的，容器的大小一般支持自定义的方式。

public LinkedBlockingQueue() {        this(Integer.MAX_VALUE);    }

当我们手动new一个容器时，初始大小分配好了，这就是整形数值的最大值，即默认开辟了这么大的数组空间，即内存空间，是不是有点浪费呢？自己思考思考。

 public LinkedBlockingQueue(int capacity) {        if (capacity <= 0) throw new IllegalArgumentException();        this.capacity = capacity;        last = head = new Node<E>(null);    }

其实，我们也可以自己手动容器的大小，，但是不能小于等于0，这里就进行了前置校验，抛出非法异常，然后将初始值赋值给数组容量，因为数据是存放在节点当中的，所以这里就暂时将new Node()的值设置为了null。

我们使用容器要干什么？装填数据呗，就是常用的offer(),put()方法，这里我们先介绍一下put()方法的源码吧。

 public void put(E e) throws InterruptedException {        if (e == null) throw new NullPointerException();        //若装填的数据为null，直接抛出空指针异常        int c = -1;        Node<E> node = new Node<E>(e);        final ReentrantLock putLock = this.putLock;//获取putLock锁        final AtomicInteger count = this.count;//获取当前队列的元素个数        putLock.lockInterruptibly();//这个锁是可中断的        try {        //这句话就是表明put方法是一个阻塞性的方法            while (count.get() == capacity) {                notFull.await();            }            //如队列操作            enqueue(node);            c = count.getAndIncrement();            if (c + 1 < capacity)                notFull.signal();        } finally {        //最后在finally语句块进行释放锁            putLock.unlock();        }        if (c == 0)            signalNotEmpty();    }

首先这是一个线程安全的方法，为什么这么说呢？看到lock了没，加锁了，同一时刻只能有一个线程进行操作，保证了多线程下共享数据的安全。

LinkedBlockingQueue不允许队列的元素为null，所以，这里在入队列之前就进行了前置校验，若元素e为空，则直接抛出NPE异常，阻断程序的运行，在入队列之前先判断队列是否已满，若已满则等待，这也是为什么之前有的面试官总是会问到put()方法和其它添加元素方法的区别，是不是看过源码之后一目了然。

private void enqueue(Node<E> node) {              last = last.next = node;    }

入队列很简单，就是将新增节点数据直接连接到队列的尾部，这样就保证了队列的先入先出特点。

好了，put()方法的过程到这里就结束了，接下来我们在看下其它方法吧。

就暂时先看下take()方法的实现过程吧，首先这个take()方法也是一个阻塞性方法，队列若没有数据，则直接等待。

 public E take() throws InterruptedException {        E x;        int c = -1;        final AtomicInteger count = this.count;//获取当前队列元素的个数        final ReentrantLock takeLock = this.takeLock;//获取takeLock锁        takeLock.lockInterruptibly();//进行加锁操作        try {            while (count.get() == 0) {//判断队列的元素个数是否为0，若为0则等待                notEmpty.await();            }            x = dequeue();//出队列操作            c = count.getAndDecrement();            if (c > 1)                notEmpty.signal();        } finally {        //释放锁操作            takeLock.unlock();        }        if (c == capacity)            signalNotFull();        return x;    }

首先判断当前队列的元素个数是否为0，若为0，则等待，这里就基于condition的await()方法实现的等待机制。然后就是dequeue()方法了，

 private E dequeue() {        Node<E> h = head;        Node<E> first = h.next;        h.next = h; // help GC        head = first;        E x = first.item;        first.item = null;        return x;    }

出队列就将数据置为null,便于GC进行不可用数据的回收，其实在你看这部分时了解一下jvm是很必要的，一般队列和栈都很详细，就是我想获取队列的队首元素，但是我又不想让它出队列，这样就提供了peek()方法。

public E peek() {        if (count.get() == 0)            return null;        final ReentrantLock takeLock = this.takeLock;        takeLock.lock();        try {            Node<E> first = head.next;            if (first == null)                return null;            else                return first.item;        } finally {            takeLock.unlock();        }    }

这里，首先判断队列的元素个数是否为0，若为0，则直接返回null，否则，加锁，然后获取  队列队首元素，这样就获取了你想要的队首元素，关于这部分，其实你理解了什么是锁，什么是原子类，这个分析过程和分析ArrayList源码基本上一样，没有看过我的源码分析的请历史文章进行查找。

其实熟悉我的文章的读者都知道我分析集合容器时总是喜欢分析它的isEmpty()方法和clear()方法，因为我觉得这个对于我理解集合太重要了。

 public void clear() {        fullyLock();        try {            for (Node<E> p, h = head; (p = h.next) != null; h = p) {                h.next = h;                p.item = null;            }            head = last;            if (count.getAndSet(0) == capacity)                notFull.signal();        } finally {            fullyUnlock();        }    }

循环迭代队列的元素，然后将其置为null，等待GC进行数据的回收，这样队列就清空了，然后将表示队列元素个数清零就可以了，整个过程的加锁和释放就不过多介绍了，到这里差不多队列的内容就介绍完了，方法太多，我这里就简单介绍了一部分方法，其它方法大差不差没有什么区别，所里这里就不过多介绍了，

public int size() {        return count.get();    }

这个count是原子的，即使是多线程操作下也能保证原子性。差点忘了分析这个方法了，判断元素是否在队列里。

 public boolean contains(Object o) {        if (o == null) return false;        fullyLock();        try {            for (Node<E> p = head.next; p != null; p = p.next)                if (o.equals(p.item))                    return true;            return false;        } finally {            fullyUnlock();        }    }

循环迭代队列里的元素值，与其进行比较，若相等则返回true，否则返回false，时间复杂度为O(n)，不了解时间复杂度，这里不再继续说了，需要的可以自行了解。

最后，在看下如何转为数组的方法吧，这个方法比较特殊，因为它没有调用底层的拷贝，利用的确实新开辟了一个数组，然后将数组进行填充到新的数组里面。

 public Object[] toArray() {        fullyLock();        try {            int size = count.get();            Object[] a = new Object[size];            int k = 0;            for (Node<E> p = head.next; p != null; p = p.next)                a[k++] = p.item;            return a;        } finally {            fullyUnlock();        }    }

整个过程也是加锁和释放锁的过程，所以这就是一个线程安全的容器类，到这里就结束了，时间也不早了，0:02了，好了，喜欢的内容到这里点个在看呗，到这里就结束了，后面想要分享内容再继续分享。

我喜欢分享，你喜欢阅读@WwpwW