Java多线程系列--“JUC集合”10之 ConcurrentLinkedQueue
来源:互联网 发布:风暴大陆神器进阶数据 编辑:程序博客网 时间:2024/06/03 05:27
概要
本章对Java.util.concurrent包中的ConcurrentHashMap类进行详细的介绍。内容包括:
ConcurrentLinkedQueue介绍
ConcurrentLinkedQueue原理和数据结构
ConcurrentLinkedQueue函数列表
ConcurrentLinkedQueue源码分析(JDK1.7.0_40版本)
ConcurrentLinkedQueue示例
转载请注明出处:http://www.cnblogs.com/skywang12345/p/3498995.html
ConcurrentLinkedQueue介绍
ConcurrentLinkedQueue是线程安全的队列,它适用于“高并发”的场景。
它是一个基于链接节点的无界线程安全队列,按照 FIFO(先进先出)原则对元素进行排序。队列元素中不可以放置null元素(内部实现的特殊节点除外)。
ConcurrentLinkedQueue原理和数据结构
ConcurrentLinkedQueue的数据结构,如下图所示:
说明:
1. ConcurrentLinkedQueue继承于AbstractQueue。
2. ConcurrentLinkedQueue内部是通过链表来实现的。它同时包含链表的头节点head和尾节点tail。ConcurrentLinkedQueue按照 FIFO(先进先出)原则对元素进行排序。元素都是从尾部插入到链表,从头部开始返回。
3. ConcurrentLinkedQueue的链表Node中的next的类型是volatile,而且链表数据item的类型也是volatile。关于volatile,我们知道它的语义包含:“即对一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写入”。ConcurrentLinkedQueue就是通过volatile来实现多线程对竞争资源的互斥访问的。
ConcurrentLinkedQueue函数列表
// 创建一个最初为空的 ConcurrentLinkedQueue。ConcurrentLinkedQueue()// 创建一个最初包含给定 collection 元素的 ConcurrentLinkedQueue,按照此 collection 迭代器的遍历顺序来添加元素。ConcurrentLinkedQueue(Collection<? extends E> c)// 将指定元素插入此队列的尾部。boolean add(E e)// 如果此队列包含指定元素,则返回 true。boolean contains(Object o)// 如果此队列不包含任何元素,则返回 true。boolean isEmpty()// 返回在此队列元素上以恰当顺序进行迭代的迭代器。Iterator<E> iterator()// 将指定元素插入此队列的尾部。boolean offer(E e)// 获取但不移除此队列的头;如果此队列为空,则返回 null。E peek()// 获取并移除此队列的头,如果此队列为空,则返回 null。E poll()// 从队列中移除指定元素的单个实例(如果存在)。boolean remove(Object o)// 返回此队列中的元素数量。int size()// 返回以恰当顺序包含此队列所有元素的数组。Object[] toArray()// 返回以恰当顺序包含此队列所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。<T> T[] toArray(T[] a)
ConcurrentLinkedQueue源码分析(JDK1.7.0_40版本)
ConcurrentLinkedQueue的完整源码如下:
1 /* 2 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12 * 13 * 14 * 15 * 16 * 17 * 18 * 19 * 20 * 21 * 22 * 23 */ 24 25 /* 26 * 27 * 28 * 29 * 30 * 31 * Written by Doug Lea and Martin Buchholz with assistance from members of 32 * JCP JSR-166 Expert Group and released to the public domain, as explained 33 * at http://creativecommons.org/publicdomain/zero/1.0/ 34 */ 35 36 package java.util.concurrent; 37 38 import java.util.AbstractQueue; 39 import java.util.ArrayList; 40 import java.util.Collection; 41 import java.util.Iterator; 42 import java.util.NoSuchElementException; 43 import java.util.Queue; 44 45 /** 46 * An unbounded thread-safe {@linkplain Queue queue} based on linked nodes. 47 * This queue orders elements FIFO (first-in-first-out). 48 * The <em>head</em> of the queue is that element that has been on the 49 * queue the longest time. 50 * The <em>tail</em> of the queue is that element that has been on the 51 * queue the shortest time. New elements 52 * are inserted at the tail of the queue, and the queue retrieval 53 * operations obtain elements at the head of the queue. 54 * A {@code ConcurrentLinkedQueue} is an appropriate choice when 55 * many threads will share access to a common collection. 56 * Like most other concurrent collection implementations, this class 57 * does not permit the use of {@code null} elements. 58 * 59 * <p>This implementation employs an efficient "wait-free" 60 * algorithm based on one described in <a 61 * href="http://www.cs.rochester.edu/u/michael/PODC96.html"> Simple, 62 * Fast, and Practical Non-Blocking and Blocking Concurrent Queue 63 * Algorithms</a> by Maged M. Michael and Michael L. Scott. 64 * 65 * <p>Iterators are <i>weakly consistent</i>, returning elements 66 * reflecting the state of the queue at some point at or since the 67 * creation of the iterator. They do <em>not</em> throw {@link 68 * java.util.ConcurrentModificationException}, and may proceed concurrently 69 * with other operations. Elements contained in the queue since the creation 70 * of the iterator will be returned exactly once. 71 * 72 * <p>Beware that, unlike in most collections, the {@code size} method 73 * is <em>NOT</em> a constant-time operation. Because of the 74 * asynchronous nature of these queues, determining the current number 75 * of elements requires a traversal of the elements, and so may report 76 * inaccurate results if this collection is modified during traversal. 77 * Additionally, the bulk operations {@code addAll}, 78 * {@code removeAll}, {@code retainAll}, {@code containsAll}, 79 * {@code equals}, and {@code toArray} are <em>not</em> guaranteed 80 * to be performed atomically. For example, an iterator operating 81 * concurrently with an {@code addAll} operation might view only some 82 * of the added elements. 83 * 84 * <p>This class and its iterator implement all of the <em>optional</em> 85 * methods of the {@link Queue} and {@link Iterator} interfaces. 86 * 87 * <p>Memory consistency effects: As with other concurrent 88 * collections, actions in a thread prior to placing an object into a 89 * {@code ConcurrentLinkedQueue} 90 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a> 91 * actions subsequent to the access or removal of that element from 92 * the {@code ConcurrentLinkedQueue} in another thread. 93 * 94 * <p>This class is a member of the 95 * <a href="{@docRoot}/../technotes/guides/collections/index.html"> 96 * Java Collections Framework</a>. 97 * 98 * @since 1.5 99 * @author Doug Lea100 * @param <E> the type of elements held in this collection101 *102 */103 public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>104 implements Queue<E>, java.io.Serializable {105 private static final long serialVersionUID = 196745693267521676L;106 107 /*108 * This is a modification of the Michael & Scott algorithm,109 * adapted for a garbage-collected environment, with support for110 * interior node deletion (to support remove(Object)). For111 * explanation, read the paper.112 *113 * Note that like most non-blocking algorithms in this package,114 * this implementation relies on the fact that in garbage115 * collected systems, there is no possibility of ABA problems due116 * to recycled nodes, so there is no need to use "counted117 * pointers" or related techniques seen in versions used in118 * non-GC'ed settings.119 *120 * The fundamental invariants are:121 * - There is exactly one (last) Node with a null next reference,122 * which is CASed when enqueueing. This last Node can be123 * reached in O(1) time from tail, but tail is merely an124 * optimization - it can always be reached in O(N) time from125 * head as well.126 * - The elements contained in the queue are the non-null items in127 * Nodes that are reachable from head. CASing the item128 * reference of a Node to null atomically removes it from the129 * queue. Reachability of all elements from head must remain130 * true even in the case of concurrent modifications that cause131 * head to advance. A dequeued Node may remain in use132 * indefinitely due to creation of an Iterator or simply a133 * poll() that has lost its time slice.134 *135 * The above might appear to imply that all Nodes are GC-reachable136 * from a predecessor dequeued Node. That would cause two problems:137 * - allow a rogue Iterator to cause unbounded memory retention138 * - cause cross-generational linking of old Nodes to new Nodes if139 * a Node was tenured while live, which generational GCs have a140 * hard time dealing with, causing repeated major collections.141 * However, only non-deleted Nodes need to be reachable from142 * dequeued Nodes, and reachability does not necessarily have to143 * be of the kind understood by the GC. We use the trick of144 * linking a Node that has just been dequeued to itself. Such a145 * self-link implicitly means to advance to head.146 *147 * Both head and tail are permitted to lag. In fact, failing to148 * update them every time one could is a significant optimization149 * (fewer CASes). As with LinkedTransferQueue (see the internal150 * documentation for that class), we use a slack threshold of two;151 * that is, we update head/tail when the current pointer appears152 * to be two or more steps away from the first/last node.153 *154 * Since head and tail are updated concurrently and independently,155 * it is possible for tail to lag behind head (why not)?156 *157 * CASing a Node's item reference to null atomically removes the158 * element from the queue. Iterators skip over Nodes with null159 * items. Prior implementations of this class had a race between160 * poll() and remove(Object) where the same element would appear161 * to be successfully removed by two concurrent operations. The162 * method remove(Object) also lazily unlinks deleted Nodes, but163 * this is merely an optimization.164 *165 * When constructing a Node (before enqueuing it) we avoid paying166 * for a volatile write to item by using Unsafe.putObject instead167 * of a normal write. This allows the cost of enqueue to be168 * "one-and-a-half" CASes.169 *170 * Both head and tail may or may not point to a Node with a171 * non-null item. If the queue is empty, all items must of course172 * be null. Upon creation, both head and tail refer to a dummy173 * Node with null item. Both head and tail are only updated using174 * CAS, so they never regress, although again this is merely an175 * optimization.176 */177 178 private static class Node<E> {179 volatile E item;180 volatile Node<E> next;181 182 /**183 * Constructs a new node. Uses relaxed write because item can184 * only be seen after publication via casNext.185 */186 Node(E item) {187 UNSAFE.putObject(this, itemOffset, item);188 }189 190 boolean casItem(E cmp, E val) {191 return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);192 }193 194 void lazySetNext(Node<E> val) {195 UNSAFE.putOrderedObject(this, nextOffset, val);196 }197 198 boolean casNext(Node<E> cmp, Node<E> val) {199 return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);200 }201 202 // Unsafe mechanics203 204 private static final sun.misc.Unsafe UNSAFE;205 private static final long itemOffset;206 private static final long nextOffset;207 208 static {209 try {210 UNSAFE = sun.misc.Unsafe.getUnsafe();211 Class k = Node.class;212 itemOffset = UNSAFE.objectFieldOffset213 (k.getDeclaredField("item"));214 nextOffset = UNSAFE.objectFieldOffset215 (k.getDeclaredField("next"));216 } catch (Exception e) {217 throw new Error(e);218 }219 }220 }221 222 /**223 * A node from which the first live (non-deleted) node (if any)224 * can be reached in O(1) time.225 * Invariants:226 * - all live nodes are reachable from head via succ()227 * - head != null228 * - (tmp = head).next != tmp || tmp != head229 * Non-invariants:230 * - head.item may or may not be null.231 * - it is permitted for tail to lag behind head, that is, for tail232 * to not be reachable from head!233 */234 private transient volatile Node<E> head;235 236 /**237 * A node from which the last node on list (that is, the unique238 * node with node.next == null) can be reached in O(1) time.239 * Invariants:240 * - the last node is always reachable from tail via succ()241 * - tail != null242 * Non-invariants:243 * - tail.item may or may not be null.244 * - it is permitted for tail to lag behind head, that is, for tail245 * to not be reachable from head!246 * - tail.next may or may not be self-pointing to tail.247 */248 private transient volatile Node<E> tail;249 250 251 /**252 * Creates a {@code ConcurrentLinkedQueue} that is initially empty.253 */254 public ConcurrentLinkedQueue() {255 head = tail = new Node<E>(null);256 }257 258 /**259 * Creates a {@code ConcurrentLinkedQueue}260 * initially containing the elements of the given collection,261 * added in traversal order of the collection's iterator.262 *263 * @param c the collection of elements to initially contain264 * @throws NullPointerException if the specified collection or any265 * of its elements are null266 */267 public ConcurrentLinkedQueue(Collection<? extends E> c) {268 Node<E> h = null, t = null;269 for (E e : c) {270 checkNotNull(e);271 Node<E> newNode = new Node<E>(e);272 if (h == null)273 h = t = newNode;274 else {275 t.lazySetNext(newNode);276 t = newNode;277 }278 }279 if (h == null)280 h = t = new Node<E>(null);281 head = h;282 tail = t;283 }284 285 // Have to override just to update the javadoc286 287 /**288 * Inserts the specified element at the tail of this queue.289 * As the queue is unbounded, this method will never throw290 * {@link IllegalStateException} or return {@code false}.291 *292 * @return {@code true} (as specified by {@link Collection#add})293 * @throws NullPointerException if the specified element is null294 */295 public boolean add(E e) {296 return offer(e);297 }298 299 /**300 * Try to CAS head to p. If successful, repoint old head to itself301 * as sentinel for succ(), below.302 */303 final void updateHead(Node<E> h, Node<E> p) {304 if (h != p && casHead(h, p))305 h.lazySetNext(h);306 }307 308 /**309 * Returns the successor of p, or the head node if p.next has been310 * linked to self, which will only be true if traversing with a311 * stale pointer that is now off the list.312 */313 final Node<E> succ(Node<E> p) {314 Node<E> next = p.next;315 return (p == next) ? head : next;316 }317 318 /**319 * Inserts the specified element at the tail of this queue.320 * As the queue is unbounded, this method will never return {@code false}.321 *322 * @return {@code true} (as specified by {@link Queue#offer})323 * @throws NullPointerException if the specified element is null324 */325 public boolean offer(E e) {326 checkNotNull(e);327 final Node<E> newNode = new Node<E>(e);328 329 for (Node<E> t = tail, p = t;;) {330 Node<E> q = p.next;331 if (q == null) {332 // p is last node333 if (p.casNext(null, newNode)) {334 // Successful CAS is the linearization point335 // for e to become an element of this queue,336 // and for newNode to become "live".337 if (p != t) // hop two nodes at a time338 casTail(t, newNode); // Failure is OK.339 return true;340 }341 // Lost CAS race to another thread; re-read next342 }343 else if (p == q)344 // We have fallen off list. If tail is unchanged, it345 // will also be off-list, in which case we need to346 // jump to head, from which all live nodes are always347 // reachable. Else the new tail is a better bet.348 p = (t != (t = tail)) ? t : head;349 else350 // Check for tail updates after two hops.351 p = (p != t && t != (t = tail)) ? t : q;352 }353 }354 355 public E poll() {356 restartFromHead:357 for (;;) {358 for (Node<E> h = head, p = h, q;;) {359 E item = p.item;360 361 if (item != null && p.casItem(item, null)) {362 // Successful CAS is the linearization point363 // for item to be removed from this queue.364 if (p != h) // hop two nodes at a time365 updateHead(h, ((q = p.next) != null) ? q : p);366 return item;367 }368 else if ((q = p.next) == null) {369 updateHead(h, p);370 return null;371 }372 else if (p == q)373 continue restartFromHead;374 else375 p = q;376 }377 }378 }379 380 public E peek() {381 restartFromHead:382 for (;;) {383 for (Node<E> h = head, p = h, q;;) {384 E item = p.item;385 if (item != null || (q = p.next) == null) {386 updateHead(h, p);387 return item;388 }389 else if (p == q)390 continue restartFromHead;391 else392 p = q;393 }394 }395 }396 397 /**398 * Returns the first live (non-deleted) node on list, or null if none.399 * This is yet another variant of poll/peek; here returning the400 * first node, not element. We could make peek() a wrapper around401 * first(), but that would cost an extra volatile read of item,402 * and the need to add a retry loop to deal with the possibility403 * of losing a race to a concurrent poll().404 */405 Node<E> first() {406 restartFromHead:407 for (;;) {408 for (Node<E> h = head, p = h, q;;) {409 boolean hasItem = (p.item != null);410 if (hasItem || (q = p.next) == null) {411 updateHead(h, p);412 return hasItem ? p : null;413 }414 else if (p == q)415 continue restartFromHead;416 else417 p = q;418 }419 }420 }421 422 /**423 * Returns {@code true} if this queue contains no elements.424 *425 * @return {@code true} if this queue contains no elements426 */427 public boolean isEmpty() {428 return first() == null;429 }430 431 /**432 * Returns the number of elements in this queue. If this queue433 * contains more than {@code Integer.MAX_VALUE} elements, returns434 * {@code Integer.MAX_VALUE}.435 *436 * <p>Beware that, unlike in most collections, this method is437 * <em>NOT</em> a constant-time operation. Because of the438 * asynchronous nature of these queues, determining the current439 * number of elements requires an O(n) traversal.440 * Additionally, if elements are added or removed during execution441 * of this method, the returned result may be inaccurate. Thus,442 * this method is typically not very useful in concurrent443 * applications.444 *445 * @return the number of elements in this queue446 */447 public int size() {448 int count = 0;449 for (Node<E> p = first(); p != null; p = succ(p))450 if (p.item != null)451 // Collection.size() spec says to max out452 if (++count == Integer.MAX_VALUE)453 break;454 return count;455 }456 457 /**458 * Returns {@code true} if this queue contains the specified element.459 * More formally, returns {@code true} if and only if this queue contains460 * at least one element {@code e} such that {@code o.equals(e)}.461 *462 * @param o object to be checked for containment in this queue463 * @return {@code true} if this queue contains the specified element464 */465 public boolean contains(Object o) {466 if (o == null) return false;467 for (Node<E> p = first(); p != null; p = succ(p)) {468 E item = p.item;469 if (item != null && o.equals(item))470 return true;471 }472 return false;473 }474 475 /**476 * Removes a single instance of the specified element from this queue,477 * if it is present. More formally, removes an element {@code e} such478 * that {@code o.equals(e)}, if this queue contains one or more such479 * elements.480 * Returns {@code true} if this queue contained the specified element481 * (or equivalently, if this queue changed as a result of the call).482 *483 * @param o element to be removed from this queue, if present484 * @return {@code true} if this queue changed as a result of the call485 */486 public boolean remove(Object o) {487 if (o == null) return false;488 Node<E> pred = null;489 for (Node<E> p = first(); p != null; p = succ(p)) {490 E item = p.item;491 if (item != null &&492 o.equals(item) &&493 p.casItem(item, null)) {494 Node<E> next = succ(p);495 if (pred != null && next != null)496 pred.casNext(p, next);497 return true;498 }499 pred = p;500 }501 return false;502 }503 504 /**505 * Appends all of the elements in the specified collection to the end of506 * this queue, in the order that they are returned by the specified507 * collection's iterator. Attempts to {@code addAll} of a queue to508 * itself result in {@code IllegalArgumentException}.509 *510 * @param c the elements to be inserted into this queue511 * @return {@code true} if this queue changed as a result of the call512 * @throws NullPointerException if the specified collection or any513 * of its elements are null514 * @throws IllegalArgumentException if the collection is this queue515 */516 public boolean addAll(Collection<? extends E> c) {517 if (c == this)518 // As historically specified in AbstractQueue#addAll519 throw new IllegalArgumentException();520 521 // Copy c into a private chain of Nodes522 Node<E> beginningOfTheEnd = null, last = null;523 for (E e : c) {524 checkNotNull(e);525 Node<E> newNode = new Node<E>(e);526 if (beginningOfTheEnd == null)527 beginningOfTheEnd = last = newNode;528 else {529 last.lazySetNext(newNode);530 last = newNode;531 }532 }533 if (beginningOfTheEnd == null)534 return false;535 536 // Atomically append the chain at the tail of this collection537 for (Node<E> t = tail, p = t;;) {538 Node<E> q = p.next;539 if (q == null) {540 // p is last node541 if (p.casNext(null, beginningOfTheEnd)) {542 // Successful CAS is the linearization point543 // for all elements to be added to this queue.544 if (!casTail(t, last)) {545 // Try a little harder to update tail,546 // since we may be adding many elements.547 t = tail;548 if (last.next == null)549 casTail(t, last);550 }551 return true;552 }553 // Lost CAS race to another thread; re-read next554 }555 else if (p == q)556 // We have fallen off list. If tail is unchanged, it557 // will also be off-list, in which case we need to558 // jump to head, from which all live nodes are always559 // reachable. Else the new tail is a better bet.560 p = (t != (t = tail)) ? t : head;561 else562 // Check for tail updates after two hops.563 p = (p != t && t != (t = tail)) ? t : q;564 }565 }566 567 /**568 * Returns an array containing all of the elements in this queue, in569 * proper sequence.570 *571 * <p>The returned array will be "safe" in that no references to it are572 * maintained by this queue. (In other words, this method must allocate573 * a new array). The caller is thus free to modify the returned array.574 *575 * <p>This method acts as bridge between array-based and collection-based576 * APIs.577 *578 * @return an array containing all of the elements in this queue579 */580 public Object[] toArray() {581 // Use ArrayList to deal with resizing.582 ArrayList<E> al = new ArrayList<E>();583 for (Node<E> p = first(); p != null; p = succ(p)) {584 E item = p.item;585 if (item != null)586 al.add(item);587 }588 return al.toArray();589 }590 591 /**592 * Returns an array containing all of the elements in this queue, in593 * proper sequence; the runtime type of the returned array is that of594 * the specified array. If the queue fits in the specified array, it595 * is returned therein. Otherwise, a new array is allocated with the596 * runtime type of the specified array and the size of this queue.597 *598 * <p>If this queue fits in the specified array with room to spare599 * (i.e., the array has more elements than this queue), the element in600 * the array immediately following the end of the queue is set to601 * {@code null}.602 *603 * <p>Like the {@link #toArray()} method, this method acts as bridge between604 * array-based and collection-based APIs. Further, this method allows605 * precise control over the runtime type of the output array, and may,606 * under certain circumstances, be used to save allocation costs.607 *608 * <p>Suppose {@code x} is a queue known to contain only strings.609 * The following code can be used to dump the queue into a newly610 * allocated array of {@code String}:611 *612 * <pre>613 * String[] y = x.toArray(new String[0]);</pre>614 *615 * Note that {@code toArray(new Object[0])} is identical in function to616 * {@code toArray()}.617 *618 * @param a the array into which the elements of the queue are to619 * be stored, if it is big enough; otherwise, a new array of the620 * same runtime type is allocated for this purpose621 * @return an array containing all of the elements in this queue622 * @throws ArrayStoreException if the runtime type of the specified array623 * is not a supertype of the runtime type of every element in624 * this queue625 * @throws NullPointerException if the specified array is null626 */627 @SuppressWarnings("unchecked")628 public <T> T[] toArray(T[] a) {629 // try to use sent-in array630 int k = 0;631 Node<E> p;632 for (p = first(); p != null && k < a.length; p = succ(p)) {633 E item = p.item;634 if (item != null)635 a[k++] = (T)item;636 }637 if (p == null) {638 if (k < a.length)639 a[k] = null;640 return a;641 }642 643 // If won't fit, use ArrayList version644 ArrayList<E> al = new ArrayList<E>();645 for (Node<E> q = first(); q != null; q = succ(q)) {646 E item = q.item;647 if (item != null)648 al.add(item);649 }650 return al.toArray(a);651 }652 653 /**654 * Returns an iterator over the elements in this queue in proper sequence.655 * The elements will be returned in order from first (head) to last (tail).656 *657 * <p>The returned iterator is a "weakly consistent" iterator that658 * will never throw {@link java.util.ConcurrentModificationException659 * ConcurrentModificationException}, and guarantees to traverse660 * elements as they existed upon construction of the iterator, and661 * may (but is not guaranteed to) reflect any modifications662 * subsequent to construction.663 *664 * @return an iterator over the elements in this queue in proper sequence665 */666 public Iterator<E> iterator() {667 return new Itr();668 }669 670 private class Itr implements Iterator<E> {671 /**672 * Next node to return item for.673 */674 private Node<E> nextNode;675 676 /**677 * nextItem holds on to item fields because once we claim678 * that an element exists in hasNext(), we must return it in679 * the following next() call even if it was in the process of680 * being removed when hasNext() was called.681 */682 private E nextItem;683 684 /**685 * Node of the last returned item, to support remove.686 */687 private Node<E> lastRet;688 689 Itr() {690 advance();691 }692 693 /**694 * Moves to next valid node and returns item to return for695 * next(), or null if no such.696 */697 private E advance() {698 lastRet = nextNode;699 E x = nextItem;700 701 Node<E> pred, p;702 if (nextNode == null) {703 p = first();704 pred = null;705 } else {706 pred = nextNode;707 p = succ(nextNode);708 }709 710 for (;;) {711 if (p == null) {712 nextNode = null;713 nextItem = null;714 return x;715 }716 E item = p.item;717 if (item != null) {718 nextNode = p;719 nextItem = item;720 return x;721 } else {722 // skip over nulls723 Node<E> next = succ(p);724 if (pred != null && next != null)725 pred.casNext(p, next);726 p = next;727 }728 }729 }730 731 public boolean hasNext() {732 return nextNode != null;733 }734 735 public E next() {736 if (nextNode == null) throw new NoSuchElementException();737 return advance();738 }739 740 public void remove() {741 Node<E> l = lastRet;742 if (l == null) throw new IllegalStateException();743 // rely on a future traversal to relink.744 l.item = null;745 lastRet = null;746 }747 }748 749 /**750 * Saves the state to a stream (that is, serializes it).751 *752 * @serialData All of the elements (each an {@code E}) in753 * the proper order, followed by a null754 * @param s the stream755 */756 private void writeObject(java.io.ObjectOutputStream s)757 throws java.io.IOException {758 759 // Write out any hidden stuff760 s.defaultWriteObject();761 762 // Write out all elements in the proper order.763 for (Node<E> p = first(); p != null; p = succ(p)) {764 Object item = p.item;765 if (item != null)766 s.writeObject(item);767 }768 769 // Use trailing null as sentinel770 s.writeObject(null);771 }772 773 /**774 * Reconstitutes the instance from a stream (that is, deserializes it).775 * @param s the stream776 */777 private void readObject(java.io.ObjectInputStream s)778 throws java.io.IOException, ClassNotFoundException {779 s.defaultReadObject();780 781 // Read in elements until trailing null sentinel found782 Node<E> h = null, t = null;783 Object item;784 while ((item = s.readObject()) != null) {785 @SuppressWarnings("unchecked")786 Node<E> newNode = new Node<E>((E) item);787 if (h == null)788 h = t = newNode;789 else {790 t.lazySetNext(newNode);791 t = newNode;792 }793 }794 if (h == null)795 h = t = new Node<E>(null);796 head = h;797 tail = t;798 }799 800 /**801 * Throws NullPointerException if argument is null.802 *803 * @param v the element804 */805 private static void checkNotNull(Object v) {806 if (v == null)807 throw new NullPointerException();808 }809 810 private boolean casTail(Node<E> cmp, Node<E> val) {811 return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);812 }813 814 private boolean casHead(Node<E> cmp, Node<E> val) {815 return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);816 }817 818 // Unsafe mechanics819 820 private static final sun.misc.Unsafe UNSAFE;821 private static final long headOffset;822 private static final long tailOffset;823 static {824 try {825 UNSAFE = sun.misc.Unsafe.getUnsafe();826 Class k = ConcurrentLinkedQueue.class;827 headOffset = UNSAFE.objectFieldOffset828 (k.getDeclaredField("head"));829 tailOffset = UNSAFE.objectFieldOffset830 (k.getDeclaredField("tail"));831 } catch (Exception e) {832 throw new Error(e);833 }834 }835 }
下面从ConcurrentLinkedQueue的创建,添加,删除这几个方面对它进行分析。
1 创建
下面以ConcurrentLinkedQueue()来进行说明。
public ConcurrentLinkedQueue() { head = tail = new Node<E>(null);}
说明:在构造函数中,新建了一个“内容为null的节点”,并设置表头head和表尾tail的值为新节点。
head和tail的定义如下:
private transient volatile Node<E> head;private transient volatile Node<E> tail;
head和tail都是volatile类型,他们具有volatile赋予的含义:“即对一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写入”。
Node的声明如下:
private static class Node<E> { volatile E item; volatile Node<E> next; Node(E item) { UNSAFE.putObject(this, itemOffset, item); } boolean casItem(E cmp, E val) { return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val); } void lazySetNext(Node<E> val) { UNSAFE.putOrderedObject(this, nextOffset, val); } boolean casNext(Node<E> cmp, Node<E> val) { return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val); } // Unsafe mechanics private static final sun.misc.Unsafe UNSAFE; private static final long itemOffset; private static final long nextOffset; static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); Class k = Node.class; itemOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("item")); nextOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("next")); } catch (Exception e) { throw new Error(e); } }}
说明:
Node是个单向链表节点,next用于指向下一个Node,item用于存储数据。Node中操作节点数据的API,都是通过Unsafe机制的CAS函数实现的;例如casNext()是通过CAS函数“比较并设置节点的下一个节点”。
2. 添加
下面以add(E e)为例对ConcurrentLinkedQueue中的添加进行说明。
public boolean add(E e) { return offer(e);}
说明:add()实际上是调用的offer()来完成添加操作的。
offer()的源码如下:
public boolean offer(E e) { // 检查e是不是null,是的话抛出NullPointerException异常。 checkNotNull(e); // 创建新的节点 final Node<E> newNode = new Node<E>(e); // 将“新的节点”添加到链表的末尾。 for (Node<E> t = tail, p = t;;) { Node<E> q = p.next; // 情况1:q为空 if (q == null) { // CAS操作:如果“p的下一个节点为null”(即p为尾节点),则设置p的下一个节点为newNode。 // 如果该CAS操作成功的话,则比较“p和t”(若p不等于t,则设置newNode为新的尾节点),然后返回true。 // 如果该CAS操作失败,这意味着“其它线程对尾节点进行了修改”,则重新循环。 if (p.casNext(null, newNode)) { if (p != t) // hop two nodes at a time casTail(t, newNode); // Failure is OK. return true; } } // 情况2:p和q相等 else if (p == q) p = (t != (t = tail)) ? t : head; // 情况3:其它 else p = (p != t && t != (t = tail)) ? t : q; }}
说明:offer(E e)的作用就是将元素e添加到链表的末尾。offer()比较的地方是理解for循环,下面区分3种情况对for进行分析。
情况1 -- q为空。这意味着q是尾节点的下一个节点。此时,通过p.casNext(null, newNode)将“p的下一个节点设为newNode”,若设置成功的话,则比较“p和t”(若p不等于t,则设置newNode为新的尾节点),然后返回true。否则的话(意味着“其它线程对尾节点进行了修改”),什么也不做,继续进行for循环。
p.casNext(null, newNode),是调用CAS对p进行操作。若“p的下一个节点等于null”,则设置“p的下一个节点等于newNode”;设置成功的话,返回true,失败的话返回false。
情况2 -- p和q相等。这种情况什么时候会发生呢?通过“情况3”,我们知道,经过“情况3”的处理后,p的值可能等于q。
此时,若尾节点没有发生变化的话,那么,应该是头节点发生了变化,则设置p为头节点,然后重新遍历链表;否则(尾节点变化的话),则设置p为尾节点。
情况3 -- 其它。
我们将p = (p != t && t != (t = tail)) ? t : q;转换成如下代码。
if (p==t) { p = q;} else { Node<E> tmp=t; t = tail; if (tmp==t) { p=q; } else { p=t; }}
如果p和t相等,则设置p为q。否则的话,判断“尾节点是否发生变化”,没有变化的话,则设置p为q;否则,设置p为尾节点。
checkNotNull()的源码如下:
private static void checkNotNull(Object v) { if (v == null) throw new NullPointerException();}
3. 删除
下面以poll()为例对ConcurrentLinkedQueue中的删除进行说明。
public E poll() { // 设置“标记” restartFromHead: for (;;) { for (Node<E> h = head, p = h, q;;) { E item = p.item; // 情况1 // 表头的数据不为null,并且“设置表头的数据为null”这个操作成功的话; // 则比较“p和h”(若p!=h,即表头发生了变化,则更新表头,即设置表头为p),然后返回原表头的item值。 if (item != null && p.casItem(item, null)) { if (p != h) // hop two nodes at a time updateHead(h, ((q = p.next) != null) ? q : p); return item; } // 情况2 // 表头的下一个节点为null,即链表只有一个“内容为null的表头节点”。则更新表头为p,并返回null。 else if ((q = p.next) == null) { updateHead(h, p); return null; } // 情况3 // 这可能到由于“情况4”的发生导致p=q,在该情况下跳转到restartFromHead标记重新操作。 else if (p == q) continue restartFromHead; // 情况4 // 设置p为q else p = q; } }}
说明:poll()的作用就是删除链表的表头节点,并返回被删节点对应的值。poll()的实现原理和offer()比较类似,下面根将or循环划分为4种情况进行分析。
情况1:“表头节点的数据”不为null,并且“设置表头节点的数据为null”这个操作成功。
p.casItem(item, null) -- 调用CAS函数,比较“节点p的数据值”与item是否相等,是的话,设置节点p的数据值为null。
在情况1发生时,先比较“p和h”,若p!=h,即表头发生了变化,则调用updateHead()更新表头;然后返回删除节点的item值。
updateHead()的源码如下:
final void updateHead(Node<E> h, Node<E> p) { if (h != p && casHead(h, p)) h.lazySetNext(h);}
说明:updateHead()的最终目的是更新表头为p,并设置h的下一个节点为h本身。
casHead(h,p)是通过CAS函数设置表头,若表头等于h的话,则设置表头为p。
lazySetNext()的源码如下:
void lazySetNext(Node<E> val) { UNSAFE.putOrderedObject(this, nextOffset, val);}
putOrderedObject()函数,我们在前面一章“TODO”中介绍过。h.lazySetNext(h)的作用是通过CAS函数设置h的下一个节点为h自身,该设置可能会延迟执行。
情况2:如果表头的下一个节点为null,即链表只有一个“内容为null的表头节点”。
则调用updateHead(h, p),将表头更新p;然后返回null。
情况3:p=q
在“情况4”的发生后,会导致p=q;此时,“情况3”就会发生。当“情况3”发生后,它会跳转到restartFromHead标记重新操作。
情况4:其它情况。
设置p=q。
ConcurrentLinkedQueue示例
1 import java.util.*; 2 import java.util.concurrent.*; 3 4 /* 5 * ConcurrentLinkedQueue是“线程安全”的队列,而LinkedList是非线程安全的。 6 * 7 * 下面是“多个线程同时操作并且遍历queue”的示例 8 * (01) 当queue是ConcurrentLinkedQueue对象时,程序能正常运行。 9 * (02) 当queue是LinkedList对象时,程序会产生ConcurrentModificationException异常。10 *11 * @author skywang12 */13 public class ConcurrentLinkedQueueDemo1 {14 15 // TODO: queue是LinkedList对象时,程序会出错。16 //private static Queue<String> queue = new LinkedList<String>();17 private static Queue<String> queue = new ConcurrentLinkedQueue<String>();18 public static void main(String[] args) {19 20 // 同时启动两个线程对queue进行操作!21 new MyThread("ta").start();22 new MyThread("tb").start();23 }24 25 private static void printAll() {26 String value;27 Iterator iter = queue.iterator();28 while(iter.hasNext()) {29 value = (String)iter.next();30 System.out.print(value+", ");31 }32 System.out.println();33 }34 35 private static class MyThread extends Thread {36 MyThread(String name) {37 super(name);38 }39 @Override40 public void run() {41 int i = 0;42 while (i++ < 6) {43 // “线程名” + "-" + "序号"44 String val = Thread.currentThread().getName()+i;45 queue.add(val);46 // 通过“Iterator”遍历queue。47 printAll();48 }49 }50 }51 }
(某一次)运行结果:
ta1, ta1, tb1, tb1,ta1, ta1, tb1, tb1, ta2, ta2, tb2, tb2, ta1, ta1, tb1, tb1, ta2, ta2, tb2, tb2, ta3, tb3, ta3, ta1, tb3, tb1, ta4, ta2, ta1, tb2, tb1, ta3, ta2, tb3, tb2, ta4, ta3, tb4, tb3, ta1, ta4, tb1, tb4, ta2, ta5, tb2, ta1, ta3, tb1, tb3, ta2, ta4, tb2, tb4, ta3, ta5, tb3, tb5, ta4, ta1, tb4, tb1, ta5, ta2, tb5, tb2, ta6, ta3, ta1, tb3, tb1, ta4, ta2, tb4, tb2, ta5, ta3, tb5, tb3, ta6, ta4, tb6, tb4, ta5, tb5, ta6, tb6,
结果说明:如果将源码中的queue改成LinkedList对象时,程序会产生ConcurrentModificationException异常。
- Java多线程系列--“JUC集合”10之 ConcurrentLinkedQueue
- Java多线程系列--“JUC集合”10之 ConcurrentLinkedQueue
- Java多线程系列--“JUC集合”10之 ConcurrentLinkedQueue
- JUC集合-10之 ConcurrentLinkedQueue
- Java多线程系列--“JUC集合”
- Java多线程系列--“JUC集合”04之 ConcurrentHashMap
- Java多线程系列--“JUC集合”01之 框架
- Java多线程系列--“JUC集合”01之 框架
- Java多线程系列--“JUC集合”02之 CopyOnWriteArrayList
- Java多线程系列--“JUC集合”03之 CopyOnWriteArraySet
- Java多线程系列--“JUC集合”04之 ConcurrentHashMap
- Java多线程系列--“JUC集合”01之 框架
- Java多线程系列--“JUC集合”02之 CopyOnWriteArrayList
- Java多线程系列--“JUC集合”03之 CopyOnWriteArraySet
- Java多线程系列--“JUC集合”04之 ConcurrentHashMap
- Java多线程系列--“JUC集合”05之 ConcurrentSkipListMap
- Java多线程系列--“JUC集合”06之 ConcurrentSkipListSet
- Java多线程系列--“JUC集合”07之 ArrayBlockingQueue
- 修改mysql自增字段的方法
- Oracle笔记(十) 约束
- django模板中插入summernote工具(bootstraphtml编辑器)
- PHPCMS手机站伪静态设置详细教程
- 欢迎使用CSDN-markdown编辑器
- Java多线程系列--“JUC集合”10之 ConcurrentLinkedQueue
- 使用vue-cli构建项目步骤
- Find All Numbers Disappeared in an Array
- 面试-java基础
- Java编程思想笔记第十一章(持有对象)
- laravel 使用elasticsearch
- Oracle笔记(十一) 建表、更新、查询综合练习
- java基础系列(二)
- 定制 proxmox VE 4.4 , 并制作安装镜像