LinkedBlockingQueue.java 33.9 KB
Newer Older
D
duke 已提交
1 2 3 4 5
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
6
 * published by the Free Software Foundation.  Oracle designates this
D
duke 已提交
7
 * particular file as subject to the "Classpath" exception as provided
8
 * by Oracle in the LICENSE file that accompanied this code.
D
duke 已提交
9 10 11 12 13 14 15 16 17 18 19
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
20 21 22
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
23 24 25 26 27 28 29 30 31 32
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
33
 * http://creativecommons.org/publicdomain/zero/1.0/
D
duke 已提交
34 35 36
 */

package java.util.concurrent;
37 38 39 40 41 42 43 44

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.AbstractQueue;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
45 46 47
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
D
duke 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61

/**
 * An optionally-bounded {@linkplain BlockingQueue blocking queue} based on
 * linked nodes.
 * This queue orders elements FIFO (first-in-first-out).
 * The <em>head</em> of the queue is that element that has been on the
 * queue the longest time.
 * The <em>tail</em> of the queue is that element that has been on the
 * queue the shortest time. New elements
 * are inserted at the tail of the queue, and the queue retrieval
 * operations obtain elements at the head of the queue.
 * Linked queues typically have higher throughput than array-based queues but
 * less predictable performance in most concurrent applications.
 *
62
 * <p>The optional capacity bound constructor argument serves as a
D
duke 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
 * way to prevent excessive queue expansion. The capacity, if unspecified,
 * is equal to {@link Integer#MAX_VALUE}.  Linked nodes are
 * dynamically created upon each insertion unless this would bring the
 * queue above capacity.
 *
 * <p>This class and its iterator implement all of the
 * <em>optional</em> methods of the {@link Collection} and {@link
 * Iterator} interfaces.
 *
 * <p>This class is a member of the
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @since 1.5
 * @author Doug Lea
 * @param <E> the type of elements held in this collection
 */
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    private static final long serialVersionUID = -6903933977591709194L;

    /*
     * A variant of the "two lock queue" algorithm.  The putLock gates
     * entry to put (and offer), and has an associated condition for
     * waiting puts.  Similarly for the takeLock.  The "count" field
     * that they both rely on is maintained as an atomic to avoid
     * needing to get both locks in most cases. Also, to minimize need
     * for puts to get takeLock and vice-versa, cascading notifies are
     * used. When a put notices that it has enabled at least one take,
     * it signals taker. That taker in turn signals others if more
     * items have been entered since the signal. And symmetrically for
     * takes signalling puts. Operations such as remove(Object) and
     * iterators acquire both locks.
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
     *
     * Visibility between writers and readers is provided as follows:
     *
     * Whenever an element is enqueued, the putLock is acquired and
     * count updated.  A subsequent reader guarantees visibility to the
     * enqueued Node by either acquiring the putLock (via fullyLock)
     * or by acquiring the takeLock, and then reading n = count.get();
     * this gives visibility to the first n items.
     *
     * To implement weakly consistent iterators, it appears we need to
     * keep all Nodes GC-reachable from a predecessor dequeued Node.
     * That would cause two problems:
     * - allow a rogue Iterator to cause unbounded memory retention
     * - cause cross-generational linking of old Nodes to new Nodes if
     *   a Node was tenured while live, which generational GCs have a
     *   hard time dealing with, causing repeated major collections.
     * However, only non-deleted Nodes need to be reachable from
     * dequeued Nodes, and reachability does not necessarily have to
     * be of the kind understood by the GC.  We use the trick of
     * linking a Node that has just been dequeued to itself.  Such a
     * self-link implicitly means to advance to head.next.
D
duke 已提交
117 118 119 120 121 122
     */

    /**
     * Linked list node class
     */
    static class Node<E> {
123 124 125 126 127 128 129 130
        E item;

        /**
         * One of:
         * - the real successor Node
         * - this Node, meaning the successor is head.next
         * - null, meaning there is no successor (this is the last node)
         */
D
duke 已提交
131
        Node<E> next;
132

D
duke 已提交
133 134 135 136 137 138 139
        Node(E x) { item = x; }
    }

    /** The capacity bound, or Integer.MAX_VALUE if none */
    private final int capacity;

    /** Current number of elements */
140
    private final AtomicInteger count = new AtomicInteger();
D
duke 已提交
141

142 143 144 145
    /**
     * Head of linked list.
     * Invariant: head.item == null
     */
146
    transient Node<E> head;
D
duke 已提交
147

148 149 150 151
    /**
     * Tail of linked list.
     * Invariant: last.next == null
     */
D
duke 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
    private transient Node<E> last;

    /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock();

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();

    /**
     * Signals a waiting take. Called only from put/offer (which do not
     * otherwise ordinarily lock takeLock.)
     */
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }

    /**
     * Signals a waiting put. Called only from take/poll.
     */
    private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }

    /**
194
     * Links node at end of queue.
195
     *
196
     * @param node the node
D
duke 已提交
197
     */
198
    private void enqueue(Node<E> node) {
199 200
        // assert putLock.isHeldByCurrentThread();
        // assert last.next == null;
201
        last = last.next = node;
D
duke 已提交
202 203 204
    }

    /**
205 206
     * Removes a node from head of queue.
     *
D
duke 已提交
207 208
     * @return the node
     */
209 210 211 212 213 214
    private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
D
duke 已提交
215 216 217 218 219 220 221
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }

    /**
222
     * Locks to prevent both puts and takes.
D
duke 已提交
223
     */
224
    void fullyLock() {
D
duke 已提交
225 226 227 228 229
        putLock.lock();
        takeLock.lock();
    }

    /**
230
     * Unlocks to allow both puts and takes.
D
duke 已提交
231
     */
232
    void fullyUnlock() {
D
duke 已提交
233 234 235 236
        takeLock.unlock();
        putLock.unlock();
    }

237 238 239 240 241 242 243
//     /**
//      * Tells whether both locks are held by current thread.
//      */
//     boolean isFullyLocked() {
//         return (putLock.isHeldByCurrentThread() &&
//                 takeLock.isHeldByCurrentThread());
//     }
D
duke 已提交
244 245

    /**
246
     * Creates a {@code LinkedBlockingQueue} with a capacity of
D
duke 已提交
247 248 249 250 251 252 253
     * {@link Integer#MAX_VALUE}.
     */
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

    /**
254
     * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity.
D
duke 已提交
255 256
     *
     * @param capacity the capacity of this queue
257
     * @throws IllegalArgumentException if {@code capacity} is not greater
D
duke 已提交
258 259 260 261 262 263 264 265 266
     *         than zero
     */
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

    /**
267
     * Creates a {@code LinkedBlockingQueue} with a capacity of
D
duke 已提交
268 269 270 271 272 273 274 275 276 277
     * {@link Integer#MAX_VALUE}, initially containing the elements of the
     * given collection,
     * added in traversal order of the collection's iterator.
     *
     * @param c the collection of elements to initially contain
     * @throws NullPointerException if the specified collection or any
     *         of its elements are null
     */
    public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
278 279 280 281 282 283 284 285 286
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); // Never contended, but necessary for visibility
        try {
            int n = 0;
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
287
                enqueue(new Node<E>(e));
288 289 290 291 292 293
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
D
duke 已提交
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
    }

    // this doc comment is overridden to remove the reference to collections
    // greater in size than Integer.MAX_VALUE
    /**
     * Returns the number of elements in this queue.
     *
     * @return the number of elements in this queue
     */
    public int size() {
        return count.get();
    }

    // this doc comment is a modified copy of the inherited doc comment,
    // without the reference to unlimited queues.
    /**
     * Returns the number of additional elements that this queue can ideally
     * (in the absence of memory or resource constraints) accept without
     * blocking. This is always equal to the initial capacity of this queue
313
     * less the current {@code size} of this queue.
D
duke 已提交
314 315
     *
     * <p>Note that you <em>cannot</em> always tell if an attempt to insert
316
     * an element will succeed by inspecting {@code remainingCapacity}
D
duke 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
     * because it may be the case that another thread is about to
     * insert or remove an element.
     */
    public int remainingCapacity() {
        return capacity - count.get();
    }

    /**
     * Inserts the specified element at the tail of this queue, waiting if
     * necessary for space to become available.
     *
     * @throws InterruptedException {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
333 334
        // Note: convention in all put/take/etc is to preset local var
        // holding count negative to indicate failure unless set.
D
duke 已提交
335
        int c = -1;
336
        Node<E> node = new Node<E>(e);
D
duke 已提交
337 338 339 340 341 342 343 344 345
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            /*
             * Note that count is used in wait guard even though it is
             * not protected by lock. This works because count can
             * only decrease at this point (all other puts are shut
             * out by lock), and we (or some other waiting put) are
346 347
             * signalled if it ever changes from capacity. Similarly
             * for all other uses of count in other wait guards.
D
duke 已提交
348
             */
349 350
            while (count.get() == capacity) {
                notFull.await();
D
duke 已提交
351
            }
352
            enqueue(node);
D
duke 已提交
353 354 355 356 357 358 359 360 361 362 363 364 365 366
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

    /**
     * Inserts the specified element at the tail of this queue, waiting if
     * necessary up to the specified wait time for space to become available.
     *
367
     * @return {@code true} if successful, or {@code false} if
368
     *         the specified waiting time elapses before space is available
D
duke 已提交
369 370 371 372 373 374 375 376 377 378 379 380 381
     * @throws InterruptedException {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

        if (e == null) throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        int c = -1;
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
382
            while (count.get() == capacity) {
D
duke 已提交
383 384
                if (nanos <= 0)
                    return false;
385
                nanos = notFull.awaitNanos(nanos);
D
duke 已提交
386
            }
387
            enqueue(new Node<E>(e));
388 389 390
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
D
duke 已提交
391 392 393 394 395 396 397 398 399 400 401
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return true;
    }

    /**
     * Inserts the specified element at the tail of this queue if it is
     * possible to do so immediately without exceeding the queue's capacity,
402
     * returning {@code true} upon success and {@code false} if this queue
D
duke 已提交
403 404 405 406 407 408 409 410 411 412 413 414 415
     * is full.
     * When using a capacity-restricted queue, this method is generally
     * preferable to method {@link BlockingQueue#add add}, which can fail to
     * insert an element only by throwing an exception.
     *
     * @throws NullPointerException if the specified element is null
     */
    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false;
        int c = -1;
416
        Node<E> node = new Node<E>(e);
D
duke 已提交
417 418 419 420
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            if (count.get() < capacity) {
421
                enqueue(node);
D
duke 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return c >= 0;
    }

    public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
441 442
            while (count.get() == 0) {
                notEmpty.await();
D
duke 已提交
443
            }
444
            x = dequeue();
D
duke 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        E x = null;
        int c = -1;
        long nanos = unit.toNanos(timeout);
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
464
            while (count.get() == 0) {
D
duke 已提交
465 466
                if (nanos <= 0)
                    return null;
467
                nanos = notEmpty.awaitNanos(nanos);
D
duke 已提交
468
            }
469 470 471 472
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
D
duke 已提交
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

    public E poll() {
        final AtomicInteger count = this.count;
        if (count.get() == 0)
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            if (count.get() > 0) {
491
                x = dequeue();
D
duke 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
                c = count.getAndDecrement();
                if (c > 1)
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

    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();
        }
    }

520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
    /**
     * Unlinks interior Node p with predecessor trail.
     */
    void unlink(Node<E> p, Node<E> trail) {
        // assert isFullyLocked();
        // p.next is not changed, to allow iterators that are
        // traversing p to maintain their weak-consistency guarantee.
        p.item = null;
        trail.next = p.next;
        if (last == p)
            last = trail;
        if (count.getAndDecrement() == capacity)
            notFull.signal();
    }

D
duke 已提交
535 536
    /**
     * Removes a single instance of the specified element from this queue,
537 538
     * if it is present.  More formally, removes an element {@code e} such
     * that {@code o.equals(e)}, if this queue contains one or more such
D
duke 已提交
539
     * elements.
540
     * Returns {@code true} if this queue contained the specified element
D
duke 已提交
541 542 543
     * (or equivalently, if this queue changed as a result of the call).
     *
     * @param o element to be removed from this queue, if present
544
     * @return {@code true} if this queue changed as a result of the call
D
duke 已提交
545 546 547 548 549
     */
    public boolean remove(Object o) {
        if (o == null) return false;
        fullyLock();
        try {
550 551 552
            for (Node<E> trail = head, p = trail.next;
                 p != null;
                 trail = p, p = p.next) {
D
duke 已提交
553
                if (o.equals(p.item)) {
554 555
                    unlink(p, trail);
                    return true;
D
duke 已提交
556 557
                }
            }
558
            return false;
D
duke 已提交
559 560 561 562 563
        } finally {
            fullyUnlock();
        }
    }

564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
    /**
     * Returns {@code true} if this queue contains the specified element.
     * More formally, returns {@code true} if and only if this queue contains
     * at least one element {@code e} such that {@code o.equals(e)}.
     *
     * @param o object to be checked for containment in this queue
     * @return {@code true} if this queue contains the specified element
     */
    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();
        }
    }

D
duke 已提交
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
    /**
     * Returns an array containing all of the elements in this queue, in
     * proper sequence.
     *
     * <p>The returned array will be "safe" in that no references to it are
     * maintained by this queue.  (In other words, this method must allocate
     * a new array).  The caller is thus free to modify the returned array.
     *
     * <p>This method acts as bridge between array-based and collection-based
     * APIs.
     *
     * @return an array containing all of the elements in this queue
     */
    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();
        }
    }

    /**
     * Returns an array containing all of the elements in this queue, in
     * proper sequence; the runtime type of the returned array is that of
     * the specified array.  If the queue fits in the specified array, it
     * is returned therein.  Otherwise, a new array is allocated with the
     * runtime type of the specified array and the size of this queue.
     *
     * <p>If this queue fits in the specified array with room to spare
     * (i.e., the array has more elements than this queue), the element in
     * the array immediately following the end of the queue is set to
622
     * {@code null}.
D
duke 已提交
623 624 625 626 627 628
     *
     * <p>Like the {@link #toArray()} method, this method acts as bridge between
     * array-based and collection-based APIs.  Further, this method allows
     * precise control over the runtime type of the output array, and may,
     * under certain circumstances, be used to save allocation costs.
     *
629
     * <p>Suppose {@code x} is a queue known to contain only strings.
D
duke 已提交
630
     * The following code can be used to dump the queue into a newly
631
     * allocated array of {@code String}:
D
duke 已提交
632
     *
633
     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
D
duke 已提交
634
     *
635 636
     * Note that {@code toArray(new Object[0])} is identical in function to
     * {@code toArray()}.
D
duke 已提交
637 638 639 640 641 642 643 644 645 646
     *
     * @param a the array into which the elements of the queue are to
     *          be stored, if it is big enough; otherwise, a new array of the
     *          same runtime type is allocated for this purpose
     * @return an array containing all of the elements in this queue
     * @throws ArrayStoreException if the runtime type of the specified array
     *         is not a supertype of the runtime type of every element in
     *         this queue
     * @throws NullPointerException if the specified array is null
     */
647
    @SuppressWarnings("unchecked")
D
duke 已提交
648 649 650 651 652 653 654 655 656
    public <T> T[] toArray(T[] a) {
        fullyLock();
        try {
            int size = count.get();
            if (a.length < size)
                a = (T[])java.lang.reflect.Array.newInstance
                    (a.getClass().getComponentType(), size);

            int k = 0;
657
            for (Node<E> p = head.next; p != null; p = p.next)
D
duke 已提交
658 659 660 661 662 663 664 665 666 667 668 669
                a[k++] = (T)p.item;
            if (a.length > k)
                a[k] = null;
            return a;
        } finally {
            fullyUnlock();
        }
    }

    public String toString() {
        fullyLock();
        try {
670 671 672 673 674 675 676 677 678 679 680 681 682 683
            Node<E> p = head.next;
            if (p == null)
                return "[]";

            StringBuilder sb = new StringBuilder();
            sb.append('[');
            for (;;) {
                E e = p.item;
                sb.append(e == this ? "(this Collection)" : e);
                p = p.next;
                if (p == null)
                    return sb.append(']').toString();
                sb.append(',').append(' ');
            }
D
duke 已提交
684 685 686 687 688 689 690 691 692 693 694 695
        } finally {
            fullyUnlock();
        }
    }

    /**
     * Atomically removes all of the elements from this queue.
     * The queue will be empty after this call returns.
     */
    public void clear() {
        fullyLock();
        try {
696 697 698 699 700 701
            for (Node<E> p, h = head; (p = h.next) != null; h = p) {
                h.next = h;
                p.item = null;
            }
            head = last;
            // assert head.item == null && head.next == null;
D
duke 已提交
702
            if (count.getAndSet(0) == capacity)
703
                notFull.signal();
D
duke 已提交
704 705 706 707 708 709 710 711 712 713 714 715
        } finally {
            fullyUnlock();
        }
    }

    /**
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @throws IllegalArgumentException      {@inheritDoc}
     */
    public int drainTo(Collection<? super E> c) {
716
        return drainTo(c, Integer.MAX_VALUE);
D
duke 已提交
717 718 719 720 721 722 723 724 725 726 727 728 729
    }

    /**
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @throws IllegalArgumentException      {@inheritDoc}
     */
    public int drainTo(Collection<? super E> c, int maxElements) {
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
730 731
        if (maxElements <= 0)
            return 0;
732 733 734
        boolean signalNotFull = false;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
D
duke 已提交
735
        try {
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
            int n = Math.min(maxElements, count.get());
            // count.get provides visibility to first n Nodes
            Node<E> h = head;
            int i = 0;
            try {
                while (i < n) {
                    Node<E> p = h.next;
                    c.add(p.item);
                    p.item = null;
                    h.next = h;
                    h = p;
                    ++i;
                }
                return n;
            } finally {
                // Restore invariants even if c.add() threw
                if (i > 0) {
                    // assert h.item == null;
                    head = h;
                    signalNotFull = (count.getAndAdd(-i) == capacity);
                }
D
duke 已提交
757 758
            }
        } finally {
759 760 761
            takeLock.unlock();
            if (signalNotFull)
                signalNotFull();
D
duke 已提交
762 763 764 765 766
        }
    }

    /**
     * Returns an iterator over the elements in this queue in proper sequence.
767 768 769
     * The elements will be returned in order from first (head) to last (tail).
     *
     * <p>The returned iterator is a "weakly consistent" iterator that
M
martin 已提交
770
     * will never throw {@link java.util.ConcurrentModificationException
771 772 773 774
     * ConcurrentModificationException}, and guarantees to traverse
     * elements as they existed upon construction of the iterator, and
     * may (but is not guaranteed to) reflect any modifications
     * subsequent to construction.
D
duke 已提交
775 776 777 778
     *
     * @return an iterator over the elements in this queue in proper sequence
     */
    public Iterator<E> iterator() {
779
        return new Itr();
D
duke 已提交
780 781 782 783
    }

    private class Itr implements Iterator<E> {
        /*
784
         * Basic weakly-consistent iterator.  At all times hold the next
D
duke 已提交
785 786 787
         * item to hand out so that if hasNext() reports true, we will
         * still have it to return even if lost race with a take etc.
         */
788

D
duke 已提交
789 790 791 792 793
        private Node<E> current;
        private Node<E> lastRet;
        private E currentElement;

        Itr() {
794
            fullyLock();
D
duke 已提交
795 796 797 798 799
            try {
                current = head.next;
                if (current != null)
                    currentElement = current.item;
            } finally {
800
                fullyUnlock();
D
duke 已提交
801 802 803 804 805 806 807
            }
        }

        public boolean hasNext() {
            return current != null;
        }

808
        /**
809 810 811
         * Returns the next live successor of p, or null if no such.
         *
         * Unlike other traversal methods, iterators need to handle both:
812
         * - dequeued nodes (p.next == p)
813
         * - (possibly multiple) interior removed nodes (p.item == null)
814 815
         */
        private Node<E> nextNode(Node<E> p) {
816 817 818 819 820 821 822 823
            for (;;) {
                Node<E> s = p.next;
                if (s == p)
                    return head.next;
                if (s == null || s.item != null)
                    return s;
                p = s;
            }
824 825
        }

D
duke 已提交
826
        public E next() {
827
            fullyLock();
D
duke 已提交
828 829 830 831 832
            try {
                if (current == null)
                    throw new NoSuchElementException();
                E x = currentElement;
                lastRet = current;
833 834
                current = nextNode(current);
                currentElement = (current == null) ? null : current.item;
D
duke 已提交
835 836
                return x;
            } finally {
837
                fullyUnlock();
D
duke 已提交
838 839 840 841 842 843
            }
        }

        public void remove() {
            if (lastRet == null)
                throw new IllegalStateException();
844
            fullyLock();
D
duke 已提交
845 846 847
            try {
                Node<E> node = lastRet;
                lastRet = null;
848 849 850 851 852 853 854
                for (Node<E> trail = head, p = trail.next;
                     p != null;
                     trail = p, p = p.next) {
                    if (p == node) {
                        unlink(p, trail);
                        break;
                    }
D
duke 已提交
855 856
                }
            } finally {
857
                fullyUnlock();
D
duke 已提交
858 859 860 861
            }
        }
    }

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
    /** A customized variant of Spliterators.IteratorSpliterator */
    static final class LBQSpliterator<E> implements Spliterator<E> {
        static final int MAX_BATCH = 1 << 25;  // max batch array size;
        final LinkedBlockingQueue<E> queue;
        Node<E> current;    // current node; null until initialized
        int batch;          // batch size for splits
        boolean exhausted;  // true when no more nodes
        long est;           // size estimate
        LBQSpliterator(LinkedBlockingQueue<E> queue) {
            this.queue = queue;
            this.est = queue.size();
        }

        public long estimateSize() { return est; }

        public Spliterator<E> trySplit() {
            Node<E> h;
            final LinkedBlockingQueue<E> q = this.queue;
            int b = batch;
            int n = (b <= 0) ? 1 : (b >= MAX_BATCH) ? MAX_BATCH : b + 1;
            if (!exhausted &&
                ((h = current) != null || (h = q.head.next) != null) &&
                h.next != null) {
                Object[] a = new Object[n];
                int i = 0;
                Node<E> p = current;
                q.fullyLock();
                try {
                    if (p != null || (p = q.head.next) != null) {
                        do {
                            if ((a[i] = p.item) != null)
                                ++i;
                        } while ((p = p.next) != null && i < n);
                    }
                } finally {
                    q.fullyUnlock();
                }
                if ((current = p) == null) {
                    est = 0L;
                    exhausted = true;
                }
                else if ((est -= i) < 0L)
                    est = 0L;
                if (i > 0) {
                    batch = i;
                    return Spliterators.spliterator
                        (a, 0, i, Spliterator.ORDERED | Spliterator.NONNULL |
                         Spliterator.CONCURRENT);
                }
            }
            return null;
        }

        public void forEachRemaining(Consumer<? super E> action) {
            if (action == null) throw new NullPointerException();
            final LinkedBlockingQueue<E> q = this.queue;
            if (!exhausted) {
                exhausted = true;
                Node<E> p = current;
                do {
                    E e = null;
                    q.fullyLock();
                    try {
                        if (p == null)
                            p = q.head.next;
                        while (p != null) {
                            e = p.item;
                            p = p.next;
                            if (e != null)
                                break;
                        }
                    } finally {
                        q.fullyUnlock();
                    }
                    if (e != null)
                        action.accept(e);
                } while (p != null);
            }
        }

        public boolean tryAdvance(Consumer<? super E> action) {
            if (action == null) throw new NullPointerException();
            final LinkedBlockingQueue<E> q = this.queue;
            if (!exhausted) {
                E e = null;
                q.fullyLock();
                try {
                    if (current == null)
                        current = q.head.next;
                    while (current != null) {
                        e = current.item;
                        current = current.next;
                        if (e != null)
                            break;
                    }
                } finally {
                    q.fullyUnlock();
                }
                if (current == null)
                    exhausted = true;
                if (e != null) {
                    action.accept(e);
                    return true;
                }
            }
            return false;
        }

        public int characteristics() {
            return Spliterator.ORDERED | Spliterator.NONNULL |
                Spliterator.CONCURRENT;
        }
    }

    public Spliterator<E> spliterator() {
        return new LBQSpliterator<E>(this);
    }

D
duke 已提交
980
    /**
981
     * Saves this queue to a stream (that is, serializes it).
D
duke 已提交
982 983
     *
     * @serialData The capacity is emitted (int), followed by all of
984
     * its elements (each an {@code Object}) in the proper order,
D
duke 已提交
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
     * followed by a null
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {

        fullyLock();
        try {
            // Write out any hidden stuff, plus capacity
            s.defaultWriteObject();

            // Write out all elements in the proper order.
            for (Node<E> p = head.next; p != null; p = p.next)
                s.writeObject(p.item);

            // Use trailing null as sentinel
            s.writeObject(null);
        } finally {
            fullyUnlock();
        }
    }

    /**
1007
     * Reconstitutes this queue from a stream (that is, deserializes it).
D
duke 已提交
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in capacity, and any hidden stuff
        s.defaultReadObject();

        count.set(0);
        last = head = new Node<E>(null);

        // Read in all elements and place in queue
        for (;;) {
1019
            @SuppressWarnings("unchecked")
D
duke 已提交
1020 1021 1022 1023 1024 1025 1026
            E item = (E)s.readObject();
            if (item == null)
                break;
            add(item);
        }
    }
}