今天要介绍的是基础容器类（为了与并发容器类区分开来而命名的名字）中的另一个成员——PriorityQueue，它的大名叫做优先级队列，想必即使没有用过也该有所耳闻吧，什么？没。。没听过？emmm。。。那就更该认真看看了。

通过本篇你将了解到：

1、PriorityQueue是什么？

2、PriorityQueue的内部结构是什么？

3、二叉堆、大顶堆、小顶堆分别是什么？有什么特性？

4、小顶堆是如何实现的，如何用数组表示？

5、小顶堆的删除、插入操作是如何进行的？

6、PriorityQueue的源码解析。

7、PriorityQueue的应用场景。

一、PriorityQueue简介

PriorityQueue也是Queue的一个继承者，相比于一般的列表，它的特点便如它的名字一样，出队的时候可以按照优先级进行出队，所以不像LinkedList那样只能按照插入的顺序出队，PriorityQueue是可以根据给定的优先级顺序进行出队的。这里说的给定优先级顺序既可以是内部比较器，也可以是外部比较器。PriorityQueue内部是根据小顶堆的结构进行存储的，所谓小顶堆的意思，便是最小的元素总是在最上面，每次出队总是将堆顶元素移除，这样便能让出队变得有序，至于什么是小顶堆，后面会有详细介绍。

比如说，比较常见的场景就是任务队列，队列动态插入，后面的任务优先级高的需要被先执行，那么使用优先级队列就可以比较好的实现这样的需求。下面我们模拟一下这个场景：

  1. public class PriorityQueueTest {
  2.     public static void main(String[] args){
  3.         // 传入外部比较器，
  4.         //PriorityQueue<Task> taskQueue = new PriorityQueue<>(Comparator.comparingInt(Task::getPriority));
  5.         //PriorityQueue<Task> taskQueue = new PriorityQueue<>((t1, t2) -> t1.getPriority() - t2.getPriority());
  6.         PriorityQueue<Task> taskQueue = new PriorityQueue<>(new Comparator<Task>() {
  7.             @Override
  8.             public int compare(Task t1, Task t2) {
  9.                 return t1.getPriority() - t2.getPriority();
  10.             }
  11.         });
  13.         // 添加六个任务
  14.         taskQueue.add(new Task(1, "learn java"));
  15.         taskQueue.add(new Task(3, "learn c++"));
  16.         taskQueue.add(new Task(4, "learn c#"));
  17.         taskQueue.add(new Task(2, "learn python"));
  18.         taskQueue.add(new Task(2, "learn php"));
  19.         taskQueue.add(new Task(5, "learn js"));
  21.         // 出队
  22.         while (!taskQueue.isEmpty()){
  23.             System.out.println(taskQueue.poll());
  24.         }
  25.     }
  26. }
  28. class Task{
  29.     /**
  30.      * 任务优先级
  31.      */
  32.     private int priority;
  33.     /**
  34.      * 任务名称
  35.      */
  36.     private String taskName;
  38.     public Task() {
  39.     }
  41.     public Task(int priority, String taskName) {
  42.         this.priority = priority;
  43.         this.taskName = taskName;
  44.     }
  46.     public int getPriority() {
  47.         return priority;
  48.     }
  50.     public void setPriority(int priority) {
  51.         this.priority = priority;
  52.     }
  54.     public String getTaskName() {
  55.         return taskName;
  56.     }
  58.     public void setTaskName(String taskName) {
  59.         this.taskName = taskName;
  60.     }
  62.     @Override
  63.     public String toString() {
  64.         return "Task{" +
  65.                 "priority=" + priority +
  66.                 ", taskName='" + taskName + '\'' +
  67.                 '}';
  68.     }
  69. }

输出如下：

  1. Task{priority=1, taskName='learn java'}
  2. Task{priority=2, taskName='learn python'}
  3. Task{priority=2, taskName='learn php'}
  4. Task{priority=3, taskName='learn c++'}
  5. Task{priority=4, taskName='learn c#'}
  6. Task{priority=5, taskName='learn js'}

二、PriorityQueue的内部结构

上面已经提到了，PriorityQueue的内部结构其实是按照小顶堆的结构进行存储的，那么什么是小顶堆呢？说到小顶堆，还是先从堆开始介绍吧。

堆和栈一样是一种很基础的数据结构，在维基百科中的介绍如下：

堆（英语：Heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。在队列中，调度程序反复提取队列中第一个作业并运行，因为实际情况中某些时间较短的任务将等待很长时间才能结束，或者某些不短小，但具有重要性的作业，同样应当具有优先权。堆即为解决此类问题设计的一种数据结构。

用图来表示的话就像这样：

说完了堆，再来聊聊它的进化版——二叉堆，同样引用维基百科中的介绍：

二叉堆（英语：binary heap）是一种特殊的堆，二叉堆是完全二叉树或者是近似完全二叉树。二叉堆满足堆特性：父节点的键值总是保持固定的序关系于任何一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆。

当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。

其中，最大堆也叫做大顶堆或者大根堆，最小堆也叫做小顶堆或者小根堆。上面的图一其实就是一个大顶堆，而图二则是小顶堆。PriorityQueue是通过数组表示的小顶堆实现的，既然如此，PriorityQueue的排序特性自然与小顶堆的特性一致，下面便介绍小顶堆如何使用数组进行表示以及插入删除时的调整。

下面是一个由10，16，20，22，18，25，26，30，24，23构成的小顶堆：

　　将其从第一个元素开始依次从上到下，从左到右给每个元素添加一个序号，从0开始，这样就得到了相应元素在数组中的位置，而且这个序号是很有规则的，第k个元素的左孩子的序号为2k+1，右孩子的序号为2k+2，这样就很容易根据序号直接算出对应孩子的位置，时间复杂度为o(1)。这也就是为什么可以用数组来存储堆结构的原因了。

再来看看小顶堆是如何插入元素的，假设我们插入一个元素15：

插入元素的调整其实很简单，就是先插入到最后，然后再依次与其父节点进行比较，如果小于其父节点，则互换，直到不需要调整或者父节点为null为止。

那再来看看移除元素：

嗯，过程其实也很简单，先用最后的元素当替补，然后再从上往下进行调整。

三、PriorityQueue源码解析

小顶堆已经介绍完了，那PriorityQueue就没什么内容可讲了，嗯，那散了吧好了好了，不开玩笑了，接下来让我们一起来看看源码中是如何实现的。

先来继承结构：

PriorityQueue继承自AbstractQueue，像这样的Abstract开头的抽象类，想必应该不陌生了，就是继承自指定接口然后进行了一些默认实现。

来看看PriorityQueue的内部成员：

  1.     // 默认初始化容量
  2.     private static final int DEFAULT_INITIAL_CAPACITY = 11;
  4.     /**
  5.      * 优先级队列是使用平衡二叉堆表示的: 节点queue[n]的两个孩子分别为
  6.      * queue[2*n+1] 和 queue[2*(n+1)].  队列的优先级是由比较器或者
  7.      * 元素的自然排序决定的， 对于堆中的任意元素n，其后代d满足：n<=d
  8.      * 如果堆是非空的，则堆中最小值为queue[0]。
  9.      */
  10.     transient Object[] queue; 
  12.     /**
  13.      * 队列中元素个数
  14.      */
  15.     private int size = 0;
  17.     /**
  18.      * 比较器
  19.      */
  20.     private final Comparator<? super E> comparator;
  22.     /**
  23.      * 修改次数
  24.      */
  25.     transient int modCount = 0;

可以看到内部使用的是一个Object数组进行元素的存储，并对该数组进行了详细的注释，所以不管是根据子节点找父节点，还是根据父节点找子节点都肥肠的方便。

再来看看它的构造函数，有点多，一共有六个构造函数：

  1.     /**
  2.      * 使用默认的容量（11）来构造一个空的优先级队列，使用元素的自然顺序进行排序（此时元素必须实现comparable接口）
  3.      */
  4.     public PriorityQueue() {
  5.         this(DEFAULT_INITIAL_CAPACITY, null);
  6.     }
  8.     /**
  9.      * 使用指定容量来构造一个空的优先级队列，使用元素的自然顺序进行排序（此时元素必须实现comparable接口）
  10.      * 但如果指定的容量小于1则会抛出异常
  11.      */
  12.     public PriorityQueue(int initialCapacity) {
  13.         this(initialCapacity, null);
  14.     }
  16.     /**
  17.      * 使用默认的容量（11）构造一个优先级队列，使用指定的比较器进行排序
  18.      */
  19.     public PriorityQueue(Comparator<? super E> comparator) {
  20.         this(DEFAULT_INITIAL_CAPACITY, comparator);
  21.     }
  23.     /**
  24.      * 使用指定容量创建一个优先级队列，并使用指定比较器进行排序。
  25.      * 但如果指定的容量小于1则会抛出异常
  26.      */
  27.     public PriorityQueue(int initialCapacity,
  28.                          Comparator<? super E> comparator) {
  29.         if (initialCapacity < 1)
  30.             throw new IllegalArgumentException();
  31.         this.queue = new Object[initialCapacity];
  32.         this.comparator = comparator;
  33.     }
  35.     /**
  36.      * 使用指定集合的所有元素构造一个优先级队列，
  37.      * 如果该集合为SortedSet或者PriorityQueue类型，则会使用相同的顺序进行排序，
  38.      * 否则，将使用元素的自然排序（此时元素必须实现comparable接口），否则会抛出异常
  39.      * 并且集合中不能有null元素，否则会抛出异常
  40.      */
  41.     @SuppressWarnings("unchecked")
  42.     public PriorityQueue(Collection<? extends E> c) {
  43.         if (c instanceof SortedSet<?>) {
  44.             SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
  45.             this.comparator = (Comparator<? super E>) ss.comparator();
  46.             initElementsFromCollection(ss);
  47.         }
  48.         else if (c instanceof PriorityQueue<?>) {
  49.             PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
  50.             this.comparator = (Comparator<? super E>) pq.comparator();
  51.             initFromPriorityQueue(pq);
  52.         }
  53.         else {
  54.             this.comparator = null;
  55.             initFromCollection(c);
  56.         }
  57.     }
  59.     /**
  60.      * 使用指定的优先级队列中所有元素来构造一个新的优先级队列.  将使用原有顺序进行排序。
  61.      */
  62.     @SuppressWarnings("unchecked")
  63.     public PriorityQueue(PriorityQueue<? extends E> c) {
  64.         this.comparator = (Comparator<? super E>) c.comparator();
  65.         initFromPriorityQueue(c);
  66.     }
  68.     /**
  69.      * 根据指定的有序集合创建一个优先级队列，将使用原有顺序进行排序
  70.      */
  71.     @SuppressWarnings("unchecked")
  72.     public PriorityQueue(SortedSet<? extends E> c) {
  73.         this.comparator = (Comparator<? super E>) c.comparator();
  74.         initElementsFromCollection(c);
  75.     }

从集合中构造优先级队列的时候，调用了几个初始化函数：

  1.     private void initFromPriorityQueue(PriorityQueue<? extends E> c) {
  2.         if (c.getClass() == PriorityQueue.class) {
  3.             this.queue = c.toArray();
  4.             this.size = c.size();
  5.         } else {
  6.             initFromCollection(c);
  7.         }
  8.     }
  10.     private void initElementsFromCollection(Collection<? extends E> c) {
  11.         Object[] a = c.toArray();
  12.         // If c.toArray incorrectly doesn't return Object[], copy it.
  13.         if (a.getClass() != Object[].class)
  14.             a = Arrays.copyOf(a, a.length, Object[].class);
  15.         int len = a.length;
  16.         if (len == 1 || this.comparator != null)
  17.             for (int i = 0; i < len; i++)
  18.                 if (a[i] == null)
  19.                     throw new NullPointerException();
  20.         this.queue = a;
  21.         this.size = a.length;
  22.     }
  24.     private void initFromCollection(Collection<? extends E> c) {
  25.         initElementsFromCollection(c);
  26.         heapify();
  27.     }

initFromPriorityQueue即从另外一个优先级队列构造一个新的优先级队列，此时内部的数组元素不需要进行调整，只需要将原数组元素都复制过来即可。但是从其他非PriorityQueue的集合中构造优先级队列时，需要先将元素复制过来后再进行调整，此时调用的是heapify方法：

[](javascript:void(0)?

  1.     private void heapify() {
  2.         // 从最后一个非叶子节点开始从下往上调整
  3.         for (int i = (size >>> 1) - 1; i >= 0; i--)
  4.             siftDown(i, (E) queue[i]);
  5.     }
  7.     // 划重点了，这个函数即对应上面的元素删除时从上往下调整的步骤
  8.     private void siftDown(int k, E x) {
  9.         if (comparator != null)
  10.             // 如果比较器不为null，则使用比较器进行比较
  11.             siftDownUsingComparator(k, x);
  12.         else
  13.             // 否则使用元素的compareTo方法进行比较
  14.             siftDownComparable(k, x);
  15.     }
  17.     private void siftDownUsingComparator(int k, E x) {
  18.         // 使用half记录队列size的一半，如果比half小的话，说明不是叶子节点
  19.         // 因为最后一个节点的序号为size - 1，其父节点的序号为(size - 2) / 2或者(size - 3 ) / 2
  20.         // 所以half所在位置刚好是第一个叶子节点
  21.         int half = size >>> 1;
  22.         while (k < half) {
  23.             // 如果不是叶子节点，找出其孩子中较小的那个并用其替换
  24.             int child = (k << 1) + 1;
  25.             Object c = queue[child];
  26.             int right = child + 1;
  27.             if (right < size &&
  28.                 comparator.compare((E) c, (E) queue[right]) > 0)
  29.                 c = queue[child = right];
  30.             if (comparator.compare(x, (E) c) <= 0)
  31.                 break;
  32.             // 用c替换
  33.             queue[k] = c;
  34.             k = child;
  35.         }
  36.         //
  37.         queue[k] = x;
  38.     }
  39.     // 同上，只是比较的时候使用的是元素的compareTo方法
  40.     private void siftDownComparable(int k, E x) {
  41.         Comparable<? super E> key = (Comparable<? super E>)x;
  42.         int half = size >>> 1;        // 如果是非叶子节点则继续循环
  43.         while (k < half) {
  44.             int child = (k << 1) + 1;
  45.             Object c = queue[child];
  46.             int right = child + 1;
  47.             if (right < size &&
  48.                 ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
  49.                 c = queue[child = right];
  50.             if (key.compareTo((E) c) <= 0)
  51.                 break;
  52.             queue[k] = c;
  53.             k = child;
  54.         }
  55.         queue[k] = key;
  56.     }

这里可能一眼看过去有点难以理解，嗯，那就多看两眼吧。

siftDown方法是这里面比较重要的方法之一，有两个参数，一个是序号k，另一个是元素x，这个方法的作用，便是把x从k开始往下调整，使得在节点k在其子树的每相邻层中，父节点都小于其子节点。所以heapify的作用就比较明显了，从最后一个非叶子节点开始，从下往上依次调整其子树，使得最终得到的树里，根节点是最小的。这里要先理解一下为什么heapify中i的初始值要设置为(size >>> 1) - 1。因为这是最后一个非叶子节点的位置，不信的话可以随便画几个图验证一下，至于在siftDownUsingComparator方法中，int half = size >>> 1;这里half则是第一个叶子节点的位置，小于这个序号的节点都是非叶子节点，这里也可以画图验证，当然，注释中我已经做了解释。

说了这么多，也许还是不太明白，以集合{14,7,12,6,9,4,17,23,10,15,3}为例画个图吧：

嗯，这样最小的元素就被顶上去了，有没有觉得有点像冒泡排序，嗯，确实有点像。

siftDown说完了，再来看一眼siftUp吧，这里操作是十分类似的。

  1.     private void siftUp(int k, E x) {
  2.         if (comparator != null)
  3.             siftUpUsingComparator(k, x);
  4.         else
  5.             siftUpComparable(k, x);
  6.     }
  8.     @SuppressWarnings("unchecked")
  9.     private void siftUpComparable(int k, E x) {
  10.         Comparable<? super E> key = (Comparable<? super E>) x;
  11.         while (k > 0) {
  12.             int parent = (k - 1) >>> 1;
  13.             Object e = queue[parent];
  14.             if (key.compareTo((E) e) >= 0)
  15.                 break;
  16.             queue[k] = e;
  17.             k = parent;
  18.         }
  19.         queue[k] = key;
  20.     }
  22.     @SuppressWarnings("unchecked")
  23.     private void siftUpUsingComparator(int k, E x) {
  24.         while (k > 0) {
  25.             int parent = (k - 1) >>> 1;
  26.             Object e = queue[parent];
  27.             if (comparator.compare(x, (E) e) >= 0)
  28.                 break;
  29.             queue[k] = e;
  30.             k = parent;
  31.         }
  32.         queue[k] = x;
  33.     }

嗯，相信如果理解了siftDown的话，这里应该就不难理解了吧，如果还有疑问，欢迎留言。

再来看看几个常用的方法：

  1.     public boolean add(E e) {
  2.         return offer(e);
  3.     }
  5.     public boolean offer(E e) {
  6.         if (e == null)
  7.             throw new NullPointerException();
  8.         modCount++;
  9.         int i = size;
  10.         if (i >= queue.length)
  11.             grow(i + 1);
  12.         size = i + 1;
  13.         if (i == 0)
  14.             queue[0] = e;
  15.         else
  16.             siftUp(i, e);
  17.         return true;
  18.     }
  19.     // 扩容函数
  20.     private void grow(int minCapacity) {
  21.         int oldCapacity = queue.length;
  22.         // 如果当前容量比较小（小于64）的话进行双倍扩容，否则扩容50%
  23.         int newCapacity = oldCapacity + ((oldCapacity < 64) ?
  24.                                          (oldCapacity + 2) :
  25.                                          (oldCapacity >> 1));
  26.         // 如果发现扩容后溢出了，则进行调整
  27.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  28.             newCapacity = hugeCapacity(minCapacity);
  29.         queue = Arrays.copyOf(queue, newCapacity);
  30.     }
  31.     private static int hugeCapacity(int minCapacity) {
  32.         if (minCapacity < 0) // overflow
  33.             throw new OutOfMemoryError();
  34.         return (minCapacity > MAX_ARRAY_SIZE) ?
  35.             Integer.MAX_VALUE :
  36.             MAX_ARRAY_SIZE;
  37.     }
  39.     public boolean contains(Object o) {
  40.         return indexOf(o) != -1;
  41.     }
  43.     private int indexOf(Object o) {
  44.         if (o != null) {
  45.             // 查找时需要进行全局遍历，比搜索二叉树的查找效率要低
  46.             for (int i = 0; i < size; i++)
  47.                 if (o.equals(queue[i]))
  48.                     return i;
  49.         }
  50.         return -1;
  51.     }
  53.     public E poll() {
  54.         if (size == 0)
  55.             return null;
  56.         int s = --size;
  57.         modCount++;
  58.         E result = (E) queue[0];
  59.         E x = (E) queue[s];
  60.         queue[s] = null;
  61.         if (s != 0)
  62.             siftDown(0, x);
  63.         return result;
  64.     }

这里对照一下最开始说的小顶堆的插入和移除就能比较好的理解了。

最后源码中还有一个remove方法，需要稍微说明一下：

  1.     // 这里不是移除堆顶元素，而是移除指定元素
  2.     public boolean remove(Object o) {
  3.         // 先找到该元素的位置
  4.         int i = indexOf(o);
  5.         if (i == -1)
  6.             return false;
  7.         else {
  8.             removeAt(i);
  9.             return true;
  10.         }
  11.     }
  12.     // 移除指定序号的元素
  13.     private E removeAt(int i) {
  14.         // assert i >= 0 && i < size;
  15.         modCount++;
  16.         // s为最后一个元素的序号
  17.         int s = --size;
  18.         if (s == i)
  19.             queue[i] = null;
  20.         else {
  21.             // moved记录最后一个元素的值
  22.             E moved = (E) queue[s];
  23.             queue[s] = null;
  24.             // 用最后一个元素代替要移除的元素，并向下进行调整
  25.             siftDown(i, moved);
  26.             // 如果向下调整后发现moved还在该位置，则再向上进行调整
  27.             if (queue[i] == moved) {
  28.                 siftUp(i, moved);
  29.                 if (queue[i] != moved)
  30.                     return moved;
  31.             }
  32.         }
  33.         return null;
  34.     }

当移除的不是堆顶元素的时候，同样先用最后一个元素代替，然后先从被移除的位置开始向下调整，如果发现没有改动，则再向上调整。

四、PriorityQueue的应用场景

最后，来聊聊PriorityQueue的应用场景，由于内部是用数组实现的小顶堆，所以堆适用的场景它都适用，比如典型的从n个元素中取出最小（最大）的前k个，这样的场景适用PriorityQueue就能以比较小的空间代价和还算ok的时间代价进行实现，另外，优先级队列适用场景的特点便是需要动态插入元素，并且元素有优先级，需要根据一定的规则进行优先级排序。

下面以从10000个整数中取出最大的10个整数为例进行介绍。

  1. public class Test {
  2.     public static void main(String[] args){
  3.         ArrayList<Integer> integers = new ArrayList<>(10000);
  4.         Random random = new Random();
  5.         for (int i = 0; i < 10000; i++) {
  6.             Integer integer = random.nextInt();
  7.             if (!integers.contains(integer))
  8.                 integers.add(integer);
  9.         }
  10.         Integer[] largest = getLargest10(integers);
  11.         for (Integer i : largest){
  12.             System.out.print(i + " ");
  13.         }
  15.         System.out.println();
  17.         // 验证一下是否是最大的前10个
  18.         integers.sort(Comparator.comparingInt(Integer::intValue));
  19.         ArrayList<Integer> largest2 = new ArrayList<>(10);
  20.         for (int i = integers.size() - 1; i >= integers.size() - 10; i--){
  21.             largest2.add(integers.get(i));
  22.         }
  24.         // 在largest数组中查找
  25.         System.out.println(Arrays.asList(largest).containsAll(largest2));
  26.     }
  28.     public static Integer[] getLargest10(ArrayList<Integer> integers){
  29.         PriorityQueue<Integer> queue = new PriorityQueue<>(10);
  30.         for (Integer integer : integers){
  31.             queue.add(integer);
  32.             if (queue.size() > 10){
  33.                 queue.poll();
  34.             }
  35.         }
  36.         return queue.toArray(new Integer[10]);
  37.     }
  38. }

输出如下，由于是取的随机数，所以每个人的输出都会不一样。

  1. 2143974860 2143998490 2144350843 2145111627 2144739333 2145674658 2144667271 2145543903 2147209906 2145466260
  2. true

最后，我们来回答一下开头的问题：

1、PriorityQueue是什么？PriorityQueue是优先级队列，取出元素时会根据元素的优先级进行排序。

2、PriorityQueue的内部结构是什么？PriorityQueue内部是一个用数组实现的小顶堆。

3、二叉堆、大顶堆、小顶堆分别是什么？有什么特性？二叉堆是完全二叉树或者近完全二叉树，大顶堆即所有父节点大于子节点，小顶堆即所有父节点小于子节点。

4、小顶堆是如何实现的，如何用数组表示？小顶堆是用二叉树实现的，用数组表示时，父节点n的左孩子为2n+1，右孩子的序号为2n+2。

5、小顶堆的删除、插入操作是如何进行的？小顶堆删除堆顶元素后用最后一个元素替补，然后从上往下调整，插入一个元素时，先放到最后的位置，然后再从下往上调整。

6、PriorityQueue的源码解析。如上。

7、PriorityQueue的应用场景。适用于需要动态插入元素，且元素有优先级顺序的场景。

到此，本篇圆满结束。如果觉得还不错的话，记得动动小手点个赞，也欢迎关注博主，你们的支持是我写出更好博客的动力。

java读源码 之 queue源码分析（PriorityQueue，附图）的更多相关文章

  1. Java并发指南10：Java 读写锁 ReentrantReadWriteLock 源码分析

    Java 读写锁 ReentrantReadWriteLock 源码分析 转自:https://www.javadoop.com/post/reentrant-read-write-lock#toc5 ...

  2. Java读源码之ReentrantLock

    前言 ReentrantLock 可重入锁,应该是除了 synchronized 关键字外用的最多的线程同步手段了,虽然JVM维护者疯狂优化 synchronized 使其已经拥有了很好的性能.但 R ...

  3. Java读源码之ReentrantLock（2）

    前言 本文是 ReentrantLock 源码的第二篇,第一篇主要介绍了公平锁非公平锁正常的加锁解锁流程,虽然表达能力有限不知道有没有讲清楚,本着不太监的原则,本文填补下第一篇中挖的坑. Java读源 ...

  4. Java读源码之CountDownLatch

    前言 相信大家都挺熟悉 CountDownLatch 的,顾名思义就是一个栅栏,其主要作用是多线程环境下,让多个线程在栅栏门口等待,所有线程到齐后,栅栏打开程序继续执行. 案例 用一个最简单的案例引出 ...

  5. 源码分析— java读写锁ReentrantReadWriteLock

    前言 今天看Jraft的时候发现了很多地方都用到了读写锁,所以心血来潮想要分析以下读写锁是怎么实现的. 先上一个doc里面的例子: class CachedData { Object data; vo ...

  6. 【转载】深度解读 java 线程池设计思想及源码实现

    总览 开篇来一些废话.下图是 java 线程池几个相关类的继承结构: 先简单说说这个继承结构,Executor 位于最顶层,也是最简单的,就一个 execute(Runnable runnable) ...

  7. Java并发指南12：深度解读 java 线程池设计思想及源码实现

    ​深度解读 java 线程池设计思想及源码实现 转自 https://javadoop.com/2017/09/05/java-thread-pool/hmsr=toutiao.io&utm_ ...

  8. 源码之Queue

    看源码可以把python看得更透,更懂,想必也是开发人员的必经之路. 现在有个任务,写个线程池.使用Queue就能写一个最简单的,下面就来学学Queue源码. 源码之Queue: class Queu ...

  9. java集合树状结构及源码

    java集合树状结构及源码 最近一直想看一下java集合的源码,毕竟平时用的比较多,但总是感觉是跟着习惯new出来一个对象,比如ArrayList,HashMap等等,所以就简单的看了一下,了解了一下 ...

随机推荐

  1. 使用原生js实现选项卡功能实例教程

    选项卡是前端常见的基本功能,它是用多个标签页来区分不同内容,通过选择标签快速切换内容.学习本教程之前,读者需要具备html和css技能,同时需要有简单的javascript基础. 先来完成html部分 ...

  2. F - Bone Collector

    Many years ago , in Teddy’s hometown there was a man who was called “Bone Collector”. This man like ...

  3. CSS 中你应该了解的 BFC

    我们常说的文档流其实分为定位流.浮动流和普通流三种.而普通流其实就是指BFC中的FC.FC是formatting context的首字母缩写,直译过来是格式化上下文,它是页面中的一块渲染区域,有一套渲 ...

  4. Gatling 条件判断

    在使用Gatling的过程中,当前置接口异常,无法获取到数据作为其他接口的请求参数室,接口是不能请求的.或者通过feeder获取的数据要区分不同的情况请求不同的接口.此时,使用gatling的判断语句 ...

  5. [linux] linux的top命令参数详解

    简介 top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器. top显示系统当前的进程和其他状况,是一个动态显示过程,即可以通过用户按 ...

  6. java Int类型转为double 类型;string转double

    int a=12; double b=(double)a; or double c=Double.valueOf((double)a); string a_s="12"; doub ...

  7. Docker 安装 Jenkins , 并解决初始安装插件失败

    安装 Jenkins 后,初始化下载插件总是失败,导致安装不成功,重试好几次都是卡在安装插件那. 这里记录下 Docker 下怎么安装 Jenkins ,并解决初始安装插件失败问题. 安装插件失败,其 ...

  8. Java代码生成器加入postgresql数据库、HikariCP连接池、swagger2支持！

    目录 前言 PostgreSql VS MySql HikariCP VS Druid Swagger2 自定义参数配置一览 结语 前言   最近几天又抽时间给代码生成器增加了几个新功能(预计今晚发布 ...

  9. PE文件学习(2)导入表导出表

    转自:evil.eagle https://blog.csdn.net/evileagle/article/details/12176797 导出表是用来描述模块中的导出函数的结构,如果一个模块导出了 ...

  10. 防止html标签转义

    function htmlDecode ( str ) { var ele = document.createElement('span'); ele.innerHTML = str; return ...