队列-PriorityBlockingQueue

PriorityBlockingQueue是一个基于数组实现的线程安全的无界队列，原理和内部结构跟PriorityQueue基本一样，只是多了个线程安全。javadoc里面提到一句，1：理论上是无界的，所以添加元素可能导致outofmemoryerror；2.不容许添加null；3.添加的元素使用构造时候传入Comparator排序，要不然就使用元素的自然排序。

PriorityBlockingQueue是基于优先级，不是FIFO，这是个好东西，可以用来实现优先级的线程池，高优先级的先执行，低优先级的后执行。跟之前看过的几个队列一样，都是继承AbstractQueue实现BlockingQueue接口。

对于优先级的实现，是采用数组来实现堆的，大概样子画个图容易理解：

堆顶元素时最小的，对于各左右子堆也保证堆顶元素最小。

内部结构和构造：

1.  //基于数组实现的，如果构造没有传入容量，就是用默认大小  
2.  private static final int DEFAULT_INITIAL_CAPACITY = 11;  

4.  /** 
5.  * 数组最大容量 
6.  */  
7.  private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  

9.  /** 
10.  * 优先级队列数组，记住queue[n]的2个左右子元素在数组的位置为在queue[2*n+1]和queue[2*(n+1)] 
11.  */  
12.  private transient Object[] queue;  

14.  /** 
15.  * 队列元素个数 
16.  */  
17.  private transient int size;  

19.  /** 
20.  * 比较器，构造时可以选择传入，没有就null，到时候就使用元素的自然排序 
21.  */  
22.  private transient Comparator comparator;  

24.  /** 
25.  * 重入锁控制多有操作 
26.  */  
27.  private final ReentrantLock lock;  

29.  /** 
30.  * 队列为空的时候条件队列 
31.  */  
32.  private final Condition notEmpty;  

34.  /** 
35.  * 自旋锁 
36.  */  
37.  private transient volatile int allocationSpinLock;  

39.  /** 
40.  * 序列化的时候使用PriorityQueue，这个PriorityBlockingQueue几乎一模一样 
41.  */  
42.  private PriorityQueue q;  

44.  /** 
45.  * 默认构造，使用默认容量，没有比较器 
46.  */  
47.  public PriorityBlockingQueue() {  
48.  this(DEFAULT_INITIAL_CAPACITY, null);  
49.  }  

51.  public PriorityBlockingQueue(int initialCapacity) {  
52.  this(initialCapacity, null);  
53.  }  

55.  /** 
56.  * 最终调用的构造 
57.  */  
58.  public PriorityBlockingQueue(int initialCapacity,  
59.  Comparator comparator) {  
60.  if (initialCapacity < 1)  
61.  throw new IllegalArgumentException();  
62.  this.lock = new ReentrantLock();  
63.  this.notEmpty = lock.newCondition();  
64.  this.comparator = comparator;  
65.  this.queue = new Object[initialCapacity];  
66.  }

内部结构和构造没有什么特别的地方，基于数组实现优先级的堆，记住数组元素queue[n]的左节点queue[2n+1]和右节点queue[2(n+1)]，每次出队的都是queue[0]。

看下常用方法：

add、put、offer都是最终调用offer()方法:

1.  public boolean offer(E e) {  
2.  if (e == null)  
3.  throw new NullPointerException();  
4.  final ReentrantLock lock = this.lock;  
5.  lock.lock();  
6.  int n, cap;  
7.  Object[] array;  
8.  while ((n = size) >= (cap = (array = queue).length))  
9.  tryGrow(array, cap); //如果元素数量大于数组大小了，那就自动扩容，无界  
10.  try {  
11.  Comparator cmp = comparator; //这个看构造的时候入参，没有就用自然排序  
12.  if (cmp == null)  
13.  siftUpComparable(n, e, array); //所有插入都用从底向上调整  
14.  else  
15.  siftUpUsingComparator(n, e, array, cmp);  
16.  size = n + 1;  
17.  notEmpty.signal(); //添加后通知非空条件队列可以take  
18.  } finally {  
19.  lock.unlock();  
20.  }  
21.  return true;  
22.  }  
23.  //数组扩容  
24.  private void tryGrow(Object[] array, int oldCap) {  
25.  lock.unlock(); // 数组扩容的时候使用自旋锁，不需要锁主锁，先释放  
26.  Object[] newArray = null;  
27.  if (allocationSpinLock == 0 &&  
28.  UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,  
29.  0, 1)) { //cas占用自旋锁  
30.  try {  
31.  int newCap = oldCap + ((oldCap < 64) ?  
32.  (oldCap + 2) : // grow faster if small  
33.  (oldCap >> 1)); //这里容量最少是翻倍  
34.  if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow  
35.  int minCap = oldCap + 1;  
36.  if (minCap < 0 || minCap > MAX_ARRAY_SIZE)  
37.  throw new OutOfMemoryError();  
38.  newCap = MAX_ARRAY_SIZE; //扩容后，默认最大  
39.  }  
40.  if (newCap > oldCap && queue == array)  
41.  newArray = new Object[newCap];  
42.  } finally {  
43.  allocationSpinLock = 0; //扩容后释放自旋锁  
44.  }  
45.  }  
46.  if (newArray == null) // 到这里如果是本线程扩容newArray肯定是不为null，为null就是其他线程在处理扩容，那就让给别的线程处理  
47.  Thread.yield();  
48.  lock.lock(); //这里重新重入锁，因为扩容后还有其他操作  
49.  if (newArray != null && queue == array) { //这里不为null那就复制数组  
50.  queue = newArray;  
51.  System.arraycopy(array, 0, newArray, 0, oldCap);  
52.  }  
53.  }  
54.  //所有插入都用从下向上调整  
55.  private static  void siftUpComparable(int k, T x, Object[] array) {  
56.  Comparable key = (Comparable) x;  
57.  while (k > 0) {  
58.  int parent = (k - 1) >>> 1; //取待插入节点的父节点  
59.  Object e = array[parent];  
60.  if (key.compareTo((T) e) >= 0) //如果比父节点大，那就无所谓退出，直接放在k位置  
61.  break;  
62.  array[k] = e; //比父节点小，按照k位置给父节点，然后从父节点开始继续向上查找  
63.  k = parent;  
64.  }  
65.  array[k] = key;  
66.  }  
67.  //所有插入都用从底向上调整，跟siftUpComparable方法类似就是比较的时候使用了构造传入的comparator  
68.  private static  void siftUpUsingComparator(int k, T x, Object[] array,  
69.  Comparator cmp) {  
70.  while (k > 0) {  
71.  int parent = (k - 1) >>> 1;  
72.  Object e = array[parent];  
73.  if (cmp.compare(x, (T) e) >= 0)  
74.  break;  
75.  array[k] = e;  
76.  k = parent;  
77.  }  
78.  array[k] = x;  
79.  }

所有的添加元素最后都是调用offer方法，2步：扩容+存储，大体流程为：

1.加锁，检查元素数量是否大于等于数组长度，如果是，那就扩容，扩容没必要使用主锁，先释放锁，使用cas自旋锁，容量最少翻倍，释放自旋锁，可能存在竞争，检查下，是否扩容，如果扩容那就复制数组，再度加主锁；

2.看构造入参是否有comparator，有就使用，没有就自然排序，从数组待插入位置父节点开始比较大，如果大于父节点，那就直接待插入位置插入，否则就跟父节点交换，然后循环向上查找，数量加1，通知非空条件队列take，最后释放锁。

看下几个出队操作：

1.  public E poll() {  
2.  final ReentrantLock lock = this.lock;  
3.  lock.lock();  
4.  try {  
5.  return dequeue();  
6.  } finally {  
7.  lock.unlock();  
8.  }  
9.  }  

11.  public E take() throws InterruptedException {  
12.  final ReentrantLock lock = this.lock;  
13.  lock.lockInterruptibly(); //响应中断  
14.  E result;  
15.  try {  
16.  while ( (result = dequeue()) == null)  
17.  notEmpty.await(); //如果take，数组没有元素是要阻塞的  
18.  } finally {  
19.  lock.unlock();  
20.  }  
21.  return result;  
22.  }  

24.  public E poll(long timeout, TimeUnit unit) throws InterruptedException {  
25.  long nanos = unit.toNanos(timeout);  
26.  final ReentrantLock lock = this.lock;  
27.  lock.lockInterruptibly(); //响应中断  
28.  E result;  
29.  try {  
30.  while ( (result = dequeue()) == null && nanos > 0)  
31.  nanos = notEmpty.awaitNanos(nanos); //响应超时，每次唤醒的超时时间要检查  
32.  } finally {  
33.  lock.unlock();  
34.  }  
35.  return result;  
36.  }  

38.  public E peek() {  
39.  final ReentrantLock lock = this.lock;  
40.  lock.lock();  
41.  try {  
42.  return (size == 0) ? null : (E) queue[0]; //只是获取元素，不移除  
43.  } finally {  
44.  lock.unlock();  
45.  }  
46.  }  
47.  //获取的基本都调用这个方法  
48.  private E dequeue() {  
49.  int n = size - 1;  
50.  if (n < 0)  
51.  return null;  
52.  else {  
53.  Object[] array = queue;  
54.  E result = (E) array[0];  
55.  E x = (E) array[n]; //将最后一个数组元素取出作为比较基准  
56.  array[n] = null; //出队，最后一个数组清掉，相当于堆的最底层最右的叶子节点清掉  
57.  Comparator cmp = comparator;  
58.  if (cmp == null)  
59.  siftDownComparable(0, x, array, n); //从顶向下调整  
60.  else  
61.  siftDownUsingComparator(0, x, array, n, cmp);  
62.  size = n;  
63.  return result;  
64.  }  
65.  }  
66.  //从顶向下调整  
67.  private static  void siftDownComparable(int k, T x, Object[] array,  
68.  int n) {  
69.  if (n > 0) { //元素数量大于0,数组非空  
70.  Comparable key = (Comparable)x;  
71.  int half = n >>> 1;           // 最后一个叶子节点的父节点位置  
72.  while (k < half) {  
73.  int child = (k << 1) + 1; // 待调整位置左节点位置  
74.  Object c = array[child]; //左节点  
75.  int right = child + 1; //右节点  
76.  if (right < n &&  
77.  ((Comparable) c).compareTo((T) array[right]) > 0)  
78.  c = array[child = right]; //左右节点比较，取小的  
79.  if (key.compareTo((T) c) <= 0) //如果待调整key最小，那就退出，直接赋值  
80.  break;  
81.  array[k] = c; //如果key不是最小，那就取左右节点小的那个放到调整位置，然后小的那个节点位置开始再继续调整  
82.  k = child;  
83.  }  
84.  array[k] = key;  
85.  }  
86.  }

出队的大体流程：

1.加锁，获取queue[0]，清掉堆的最后一个叶子节点，并将其作为比较节点；

2.调用从顶向下调整的方法：待调整位置节点左右节点和之前的叶子节点比较，如果之前叶子节点最小，那就直接放入待调整位置，如果是叶子节点小，那就取小的那个放入待调整位置，并且将小的部分重新循环查找，循环次数根据2分查找，基本是元素数量的一半就到找到位置。

再看一个remove，因为remove方法，2中调整方式都用到了：


1.  public boolean remove(Object o) {  
2.  final ReentrantLock lock = this.lock;  
3.  lock.lock();  
4.  try {  
5.  int i = indexOf(o); //查找o在数组中位置  
6.  if (i == -1)  
7.  return false;  
8.  removeAt(i); //remove掉  
9.  return true;  
10.  } finally {  
11.  lock.unlock();  
12.  }  
13.  }  
14.  //o在数组中的位置  
15.  private int indexOf(Object o) {  
16.  if (o != null) {  
17.  Object[] array = queue;  
18.  int n = size;  
19.  for (int i = 0; i < n; i++)  
20.  if (o.equals(array[i]))  
21.  return i;  
22.  }  
23.  return -1;  
24.  }  
25.  //remove掉数组指定位置的元素  
26.  //跟之前take的dequeue相似的地方，dequeue是remove掉0的位置，然后调整也是从0的位置开始调整，这里是从指定位置调整  
27.  private void removeAt(int i) {  
28.  Object[] array = queue;  
29.  int n = size - 1;  
30.  if (n == i) // removed last element  
31.  array[i] = null;  
32.  else {  
33.  E moved = (E) array[n]; //跟dequeue一样也是最后一个叶子节点作为比较  
34.  array[n] = null;  
35.  Comparator cmp = comparator;  
36.  if (cmp == null)  
37.  siftDownComparable(i, moved, array, n); //从指定位置调整  
38.  else  
39.  siftDownUsingComparator(i, moved, array, n, cmp);  
40.  //经过从上向下调整后，如果是直接将比较节点放在待调整位置，那只能说明这个节点在以它为堆顶的堆里面最小，但不能说明从这个节点就向上查找就最大  
41.  //这里需要自底向上再来一次调整  
42.  if (array[i] == moved) {   
43.  if (cmp == null)  
44.  siftUpComparable(i, moved, array);  
45.  else  
46.  siftUpUsingComparator(i, moved, array, cmp);  
47.  }  
48.  }  
49.  size = n;  
50.  }

remove的时候有2个调整，先自顶向下调整，保证最小，然后再向上调整。
原文：https://blog.csdn.net/xiaoxufox/article/details/51860543

队列-PriorityBlockingQueue

你可能感兴趣的:(队列-PriorityBlockingQueue)