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 of32 * JCP JSR-166 Expert Group and released to the public domain, as explained33 * athttp://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 packagejava.util.concurrent;37
38 importjava.util.AbstractQueue;39 importjava.util.ArrayList;40 importjava.util.Collection;41 importjava.util.Iterator;42 importjava.util.NoSuchElementException;43 importjava.util.Queue;44
45 /**
46 * An unbounded thread-safe {@linkplainQueue queue} based on linked nodes.47 * This queue orders elements FIFO (first-in-first-out).48 * The head of the queue is that element that has been on the49 * queue the longest time.50 * The tail of the queue is that element that has been on the51 * queue the shortest time. New elements52 * are inserted at the tail of the queue, and the queue retrieval53 * operations obtain elements at the head of the queue.54 * A {@codeConcurrentLinkedQueue} is an appropriate choice when55 * many threads will share access to a common collection.56 * Like most other concurrent collection implementations, this class57 * does not permit the use of {@codenull} elements.58 *59 *
This implementation employs an efficient "wait-free"60 * algorithm based on one described in Simple,62 * Fast, and Practical Non-Blocking and Blocking Concurrent Queue63 * Algorithms by Maged M. Michael and Michael L. Scott.64 *65 *
Iterators are weakly consistent, returning elements66 * reflecting the state of the queue at some point at or since the67 * creation of the iterator. They do not throw {@link
68 * java.util.ConcurrentModificationException}, and may proceed concurrently69 * with other operations. Elements contained in the queue since the creation70 * of the iterator will be returned exactly once.71 *72 *
Beware that, unlike in most collections, the {@codesize} method73 * is NOT a constant-time operation. Because of the74 * asynchronous nature of these queues, determining the current number75 * of elements requires a traversal of the elements, and so may report76 * inaccurate results if this collection is modified during traversal.77 * Additionally, the bulk operations {@codeaddAll},78 * {@coderemoveAll}, {@coderetainAll}, {@codecontainsAll},79 * {@codeequals}, and {@codetoArray} are not guaranteed80 * to be performed atomically. For example, an iterator operating81 * concurrently with an {@codeaddAll} operation might view only some82 * of the added elements.83 *84 *
This class and its iterator implement all of the optional85 * methods of the {@linkQueue} and {@linkIterator} interfaces.86 *87 *
Memory consistency effects: As with other concurrent88 * collections, actions in a thread prior to placing an object into a89 * {@codeConcurrentLinkedQueue}90 * happen-before91 * actions subsequent to the access or removal of that element from92 * the {@codeConcurrentLinkedQueue} in another thread.93 *94 *
This class is a member of the95 * 96 * Java Collections Framework.97 *98 *@since1.599 *@authorDoug Lea100 *@param the type of elements held in this collection101 *102 */
103 public class ConcurrentLinkedQueue extends AbstractQueue
104 implements Queue, 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{179 volatileE item;180 volatile Nodenext;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 booleancasItem(E cmp, E val) {191 return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);192 }193
194 void lazySetNext(Nodeval) {195 UNSAFE.putOrderedObject(this, nextOffset, val);196 }197
198 boolean casNext(Node cmp, Nodeval) {199 return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);200 }201
202 //Unsafe mechanics
203
204 private static finalsun.misc.Unsafe UNSAFE;205 private static final longitemOffset;206 private static final longnextOffset;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 newError(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 Nodehead;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 Nodetail;249
250
251 /**
252 * Creates a {@codeConcurrentLinkedQueue} that is initially empty.253 */
254 publicConcurrentLinkedQueue() {255 head = tail = new Node(null);256 }257
258 /**
259 * Creates a {@codeConcurrentLinkedQueue}260 * initially containing the elements of the given collection,261 * added in traversal order of the collection's iterator.262 *263 *@paramc the collection of elements to initially contain264 *@throwsNullPointerException if the specified collection or any265 * of its elements are null266 */
267 public ConcurrentLinkedQueue(Collection extends E>c) {268 Node h = null, t = null;269 for(E e : c) {270 checkNotNull(e);271 Node newNode = new Node(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(null);281 head =h;282 tail =t;283 }284
285 //Have to override just to update the javadoc
286
287 /**
288 * Inserts the specified element at the tail of this queue.289 * As the queue is unbounded, this method will never throw290 * {@linkIllegalStateException} or return {@codefalse}.291 *292 *@return{@codetrue} (as specified by {@linkCollection#add})293 *@throwsNullPointerException if the specified element is null294 */
295 public booleanadd(E e) {296 returnoffer(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 h, Nodep) {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 succ(Nodep) {314 Node 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 {@codefalse}.321 *322 *@return{@codetrue} (as specified by {@linkQueue#offer})323 *@throwsNullPointerException if the specified element is null324 */
325 public booleanoffer(E e) {326 checkNotNull(e);327 final Node newNode = new Node(e);328
329 for (Node t = tail, p =t;;) {330 Node q =p.next;331 if (q == null) {332 //p is last node
333 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 time
338 casTail(t, newNode); //Failure is OK.
339 return true;340 }341 //Lost CAS race to another thread; re-read next
342 }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 else
350 //Check for tail updates after two hops.
351 p = (p != t && t != (t = tail)) ?t : q;352 }353 }354
355 publicE poll() {356 restartFromHead:357 for(;;) {358 for (Node 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 time
365 updateHead(h, ((q = p.next) != null) ?q : p);366 returnitem;367 }368 else if ((q = p.next) == null) {369 updateHead(h, p);370 return null;371 }372 else if (p ==q)373 continuerestartFromHead;374 else
375 p =q;376 }377 }378 }379
380 publicE peek() {381 restartFromHead:382 for(;;) {383 for (Node h = head, p =h, q;;) {384 E item =p.item;385 if (item != null || (q = p.next) == null) {386 updateHead(h, p);387 returnitem;388 }389 else if (p ==q)390 continuerestartFromHead;391 else
392 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 Nodefirst() {406 restartFromHead:407 for(;;) {408 for (Node 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 continuerestartFromHead;416 else
417 p =q;418 }419 }420 }421
422 /**
423 * Returns {@codetrue} if this queue contains no elements.424 *425 *@return{@codetrue} if this queue contains no elements426 */
427 public booleanisEmpty() {428 return first() == null;429 }430
431 /**
432 * Returns the number of elements in this queue. If this queue433 * contains more than {@codeInteger.MAX_VALUE} elements, returns434 * {@codeInteger.MAX_VALUE}.435 *436 *
Beware that, unlike in most collections, this method is437 * NOT 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 *@returnthe number of elements in this queue446 */
447 public intsize() {448 int count = 0;449 for (Node p = first(); p != null; p =succ(p))450 if (p.item != null)451 //Collection.size() spec says to max out
452 if (++count ==Integer.MAX_VALUE)453 break;454 returncount;455 }456
457 /**
458 * Returns {@codetrue} if this queue contains the specified element.459 * More formally, returns {@codetrue} if and only if this queue contains460 * at least one element {@codee} such that {@codeo.equals(e)}.461 *462 *@paramo object to be checked for containment in this queue463 *@return{@codetrue} if this queue contains the specified element464 */
465 public booleancontains(Object o) {466 if (o == null) return false;467 for (Node 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 {@codee} such478 * that {@codeo.equals(e)}, if this queue contains one or more such479 * elements.480 * Returns {@codetrue} if this queue contained the specified element481 * (or equivalently, if this queue changed as a result of the call).482 *483 *@paramo element to be removed from this queue, if present484 *@return{@codetrue} if this queue changed as a result of the call485 */
486 public booleanremove(Object o) {487 if (o == null) return false;488 Node pred = null;489 for (Node 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 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 {@codeaddAll} of a queue to508 * itself result in {@codeIllegalArgumentException}.509 *510 *@paramc the elements to be inserted into this queue511 *@return{@codetrue} if this queue changed as a result of the call512 *@throwsNullPointerException if the specified collection or any513 * of its elements are null514 *@throwsIllegalArgumentException if the collection is this queue515 */
516 public boolean addAll(Collection extends E>c) {517 if (c == this)518 //As historically specified in AbstractQueue#addAll
519 throw newIllegalArgumentException();520
521 //Copy c into a private chain of Nodes
522 Node beginningOfTheEnd = null, last = null;523 for(E e : c) {524 checkNotNull(e);525 Node newNode = new Node(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 collection
537 for (Node t = tail, p =t;;) {538 Node q =p.next;539 if (q == null) {540 //p is last node
541 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 next
554 }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 else
562 //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 *
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 *
This method acts as bridge between array-based and collection-based576 * APIs.577 *578 *@returnan array containing all of the elements in this queue579 */
580 publicObject[] toArray() {581 //Use ArrayList to deal with resizing.
582 ArrayList al = new ArrayList();583 for (Node p = first(); p != null; p =succ(p)) {584 E item =p.item;585 if (item != null)586 al.add(item);587 }588 returnal.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 *
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 * {@codenull}.602 *603 *
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 *
Suppose {@codex} 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 {@codeString}:611 *612 *
613 * String[] y = x.toArray(new String[0]);614 *615 * Note that {@codetoArray(new Object[0])} is identical in function to616 * {@codetoArray()}.617 *618 *@parama 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 *@returnan array containing all of the elements in this queue622 *@throwsArrayStoreException if the runtime type of the specified array623 * is not a supertype of the runtime type of every element in624 * this queue625 *@throwsNullPointerException if the specified array is null626 */
627 @SuppressWarnings("unchecked")628 public T[] toArray(T[] a) {629 //try to use sent-in array
630 int k = 0;631 Nodep;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
643 //If won't fit, use ArrayList version
644 ArrayList al = new ArrayList();645 for (Node q = first(); q != null; q =succ(q)) {646 E item =q.item;647 if (item != null)648 al.add(item);649 }650 returnal.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 *
The returned iterator is a "weakly consistent" iterator that658 * will never throw {@linkjava.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 *@returnan iterator over the elements in this queue in proper sequence665 */
666 public Iteratoriterator() {667 return newItr();668 }669
670 private class Itr implements Iterator{671 /**
672 * Next node to return item for.673 */
674 private NodenextNode;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 privateE nextItem;683
684 /**
685 * Node of the last returned item, to support remove.686 */
687 private NodelastRet;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 privateE advance() {698 lastRet =nextNode;699 E x =nextItem;700
701 Nodepred, 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 returnx;715 }716 E item =p.item;717 if (item != null) {718 nextNode =p;719 nextItem =item;720 returnx;721 } else{722 //skip over nulls
723 Node next =succ(p);724 if (pred != null && next != null)725 pred.casNext(p, next);726 p =next;727 }728 }729 }730
731 public booleanhasNext() {732 return nextNode != null;733 }734
735 publicE next() {736 if (nextNode == null) throw newNoSuchElementException();737 returnadvance();738 }739
740 public voidremove() {741 Node l =lastRet;742 if (l == null) throw newIllegalStateException();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 *@serialDataAll of the elements (each an {@codeE}) in753 * the proper order, followed by a null754 *@params the stream755 */
756 private voidwriteObject(java.io.ObjectOutputStream s)757 throwsjava.io.IOException {758
759 //Write out any hidden stuff
760 s.defaultWriteObject();761
762 //Write out all elements in the proper order.
763 for (Node 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 sentinel
770 s.writeObject(null);771 }772
773 /**
774 * Reconstitutes the instance from a stream (that is, deserializes it).775 *@params the stream776 */
777 private voidreadObject(java.io.ObjectInputStream s)778 throwsjava.io.IOException, ClassNotFoundException {779 s.defaultReadObject();780
781 //Read in elements until trailing null sentinel found
782 Node h = null, t = null;783 Object item;784 while ((item = s.readObject()) != null) {785 @SuppressWarnings("unchecked")786 Node newNode = new Node((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(null);796 head =h;797 tail =t;798 }799
800 /**
801 * Throws NullPointerException if argument is null.802 *803 *@paramv the element804 */
805 private static voidcheckNotNull(Object v) {806 if (v == null)807 throw newNullPointerException();808 }809
810 private boolean casTail(Node cmp, Nodeval) {811 return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);812 }813
814 private boolean casHead(Node cmp, Nodeval) {815 return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);816 }817
818 //Unsafe mechanics
819
820 private static finalsun.misc.Unsafe UNSAFE;821 private static final longheadOffset;822 private static final longtailOffset;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 newError(e);833 }834 }835 }
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
