(;;) { 678 E e = p.item; 679 sb.append(e == this ? "(this Collection)" : e); 680 p = p.next; 681 if (p == null) 682 return sb.append(']').toString(); 683 sb.append(',').append(' '); 684 } 685 } finally { 686 fullyUnlock(); 687 } 688 } 689 690 /** 691 * Atomically removes all of the elements from this queue. 692 * The queue will be empty after this call returns. 693 */ 694 public void clear() { 695 fullyLock(); 696 try { 697 for (Node<E> p, h = head; (p = h.next) != null; h = p) { 698 h.next = h; 699 p.item = null; 700 } 701 head = last; 702 // assert head.item == null && head.next == null; 703 if (count.getAndSet(0) == capacity) 704 notFull.signal(); 705 } finally { 706 fullyUnlock(); 707 } 708 } 709 710 /** 711 * @throws UnsupportedOperationException {@inheritDoc} 712 * @throws ClassCastException {@inheritDoc} 713 * @throws NullPointerException {@inheritDoc} 714 * @throws IllegalArgumentException {@inheritDoc} 715 */ 716 public int drainTo(Collection<? super E> c) { 717 return drainTo(c, Integer.MAX_VALUE); 718 } 719 720 /** 721 * @throws UnsupportedOperationException {@inheritDoc} 722 * @throws ClassCastException {@inheritDoc} 723 * @throws NullPointerException {@inheritDoc} 724 * @throws IllegalArgumentException {@inheritDoc} 725 */ 726 public int drainTo(Collection<? super E> c, int maxElements) { 727 if (c == null) 728 throw new NullPointerException(); 729 if (c == this) 730 throw new IllegalArgumentException(); 731 boolean signalNotFull = false; 732 final ReentrantLock takeLock = this.takeLock; 733 takeLock.lock(); 734 try { 735 int n = Math.min(maxElements, count.get()); 736 // count.get provides visibility to first n Nodes 737 Node<E> h = head; 738 int i = 0; 739 try { 740 while (i < n) { 741 Node<E> p = h.next; 742 c.add(p.item); 743 p.item = null; 744 h.next = h; 745 h = p; 746 ++i; 747 } 748 return n; 749 } finally { 750 // Restore invariants even if c.add() threw 751 if (i > 0) { 752 // assert h.item == null; 753 head = h; 754 signalNotFull = (count.getAndAdd(-i) == capacity); 755 } 756 } 757 } finally { 758 takeLock.unlock(); 759 if (signalNotFull) 760 signalNotFull(); 761 } 762 } 763 764 /** 765 * Returns an iterator over the elements in this queue in proper sequence. 766 * The elements will be returned in order from first (head) to last (tail). 767 * 768 * <p>The returned iterator is a "weakly consistent" iterator that 769 * will never throw {@link java.util.ConcurrentModificationException 770 * ConcurrentModificationException}, and guarantees to traverse 771 * elements as they existed upon construction of the iterator, and 772 * may (but is not guaranteed to) reflect any modifications 773 * subsequent to construction. 774 * 775 * @return an iterator over the elements in this queue in proper sequence 776 */ 777 public Iterator<E> iterator() { 778 return new Itr(); 779 } 780 781 private class Itr implements Iterator<E> { 782 /* 783 * Basic weakly-consistent iterator. At all times hold the next 784 * item to hand out so that if hasNext() reports true, we will 785 * still have it to return even if lost race with a take etc. 786 */ 787 private Node<E> current; 788 private Node<E> lastRet; 789 private E currentElement; 790 791 Itr() { 792 fullyLock(); 793 try { 794 current = head.next; 795 if (current != null) 796 currentElement = current.item; 797 } finally { 798 fullyUnlock(); 799 } 800 } 801 802 public boolean hasNext() { 803 return current != null; 804 } 805 806 /** 807 * Returns the next live successor of p, or null if no such. 808 * 809 * Unlike other traversal methods, iterators need to handle both: 810 * - dequeued nodes (p.next == p) 811 * - (possibly multiple) interior removed nodes (p.item == null) 812 */ 813 private Node<E> nextNode(Node<E> p) { 814 for (;;) { 815 Node<E> s = p.next; 816 if (s == p) 817 return head.next; 818 if (s == null || s.item != null) 819 return s; 820 p = s; 821 } 822 } 823 824 public E next() { 825 fullyLock(); 826 try { 827 if (current == null) 828 throw new NoSuchElementException(); 829 E x = currentElement; 830 lastRet = current; 831 current = nextNode(current); 832 currentElement = (current == null) ? null : current.item; 833 return x; 834 } finally { 835 fullyUnlock(); 836 } 837 } 838 839 public void remove() { 840 if (lastRet == null) 841 throw new IllegalStateException(); 842 fullyLock(); 843 try { 844 Node<E> node = lastRet; 845 lastRet = null; 846 for (Node<E> trail = head, p = trail.next; 847 p != null; 848 trail = p, p = p.next) { 849 if (p == node) { 850 unlink(p, trail); 851 break; 852 } 853 } 854 } finally { 855 fullyUnlock(); 856 } 857 } 858 } 859 860 /** 861 * Save the state to a stream (that is, serialize it). 862 * 863 * @serialData The capacity is emitted (int), followed by all of 864 * its elements (each an {@code Object}) in the proper order, 865 * followed by a null 866 * @param s the stream 867 */ 868 private void writeObject(java.io.ObjectOutputStream s) 869 throws java.io.IOException { 870 871 fullyLock(); 872 try { 873 // Write out any hidden stuff, plus capacity 874 s.defaultWriteObject(); 875 876 // Write out all elements in the proper order. 877 for (Node<E> p = head.next; p != null; p = p.next) 878 s.writeObject(p.item); 879 880 // Use trailing null as sentinel 881 s.writeObject(null); 882 } finally { 883 fullyUnlock(); 884 } 885 } 886 887 /** 888 * Reconstitute this queue instance from a stream (that is, 889 * deserialize it). 890 * 891 * @param s the stream 892 */ 893 private void readObject(java.io.ObjectInputStream s) 894 throws java.io.IOException, ClassNotFoundException { 895 // Read in capacity, and any hidden stuff 896 s.defaultReadObject(); 897 898 count.set(0); 899 last = head = new Node<E>(null); 900 901 // Read in all elements and place in queue 902 for (;;) { 903 @SuppressWarnings("unchecked") 904 E item = (E)s.readObject(); 905 if (item == null) 906 break; 907 add(item); 908 } 909 } 910 } Save This Page Home » openjdk-7 » java » util » concurrent » [javadoc | source] 340 /* 341 * Note that count is used in wait guard even though it is 342 * not protected by lock. This works because count can 343 * only decrease at this point (all other puts are shut 344 * out by lock), and we (or some other waiting put) are 345 * signalled if it ever changes from capacity. Similarly 346 * for all other uses of count in other wait guards. 347 */ 348 while (count.get() == capacity) { 349 notFull.await(); 350 } 351 enqueue(node); 352 c = count.getAndIncrement(); 353 if (c + 1 < capacity) 354 notFull.signal(); 355 } finally { 356 putLock.unlock(); 357 } 358 if (c == 0) 359 signalNotEmpty(); 360 } 361 362 /** 363 * Inserts the specified element at the tail of this queue, waiting if 364 * necessary up to the specified wait time for space to become available. 365 * 366 * @return {@code true} if successful, or {@code false} if 367 * the specified waiting time elapses before space is available. 368 * @throws InterruptedException {@inheritDoc} 369 * @throws NullPointerException {@inheritDoc} 370 */ 371 public boolean offer(E e, long timeout, TimeUnit unit) 372 throws InterruptedException { 373 374 if (e == null) throw new NullPointerException(); 375 long nanos = unit.toNanos(timeout); 376 int c = -1; 377 final ReentrantLock putLock = this.putLock; 378 final AtomicInteger count = this.count; 379 putLock.lockInterruptibly(); 380 try { 381 while (count.get() == capacity) { 382 if (nanos <= 0) 383 return false; 384 nanos = notFull.awaitNanos(nanos); 385 } 386 enqueue(new Node<E>(e)); 387 c = count.getAndIncrement(); 388 if (c + 1 < capacity) 389 notFull.signal(); 390 } finally { 391 putLock.unlock(); 392 } 393 if (c == 0) 394 signalNotEmpty(); 395 return true; 396 } 397 398 /** 399 * Inserts the specified element at the tail of this queue if it is 400 * possible to do so immediately without exceeding the queue's capacity, 401 * returning {@code true} upon success and {@code false} if this queue 402 * is full. 403 * When using a capacity-restricted queue, this method is generally 404 * preferable to method {@link BlockingQueue#add add}, which can fail to 405 * insert an element only by throwing an exception. 406 * 407 * @throws NullPointerException if the specified element is null 408 */ 409 public boolean offer(E e) { 410 if (e == null) throw new NullPointerException(); 411 final AtomicInteger count = this.count; 412 if (count.get() == capacity) 413 return false; 414 int c = -1; 415 Node<E> node = new Node(e); 416 final ReentrantLock putLock = this.putLock; 417 putLock.lock(); 418 try { 419 if (count.get() < capacity) { 420 enqueue(node); 421 c = count.getAndIncrement(); 422 if (c + 1 < capacity) 423 notFull.signal(); 424 } 425 } finally { 426 putLock.unlock(); 427 } 428 if (c == 0) 429 signalNotEmpty(); 430 return c >= 0; 431 } 432 433 434 public E take() throws InterruptedException { 435 E x; 436 int c = -1; 437 final AtomicInteger count = this.count; 438 final ReentrantLock takeLock = this.takeLock; 439 takeLock.lockInterruptibly(); 440 try { 441 while (count.get() == 0) { 442 notEmpty.await(); 443 } 444 x = dequeue(); 445 c = count.getAndDecrement(); 446 if (c > 1) 447 notEmpty.signal(); 448 } finally { 449 takeLock.unlock(); 450 } 451 if (c == capacity) 452 signalNotFull(); 453 return x; 454 } 455 456 public E poll(long timeout, TimeUnit unit) throws InterruptedException { 457 E x = null; 458 int c = -1; 459 long nanos = unit.toNanos(timeout); 460 final AtomicInteger count = this.count; 461 final ReentrantLock takeLock = this.takeLock; 462 takeLock.lockInterruptibly(); 463 try { 464 while (count.get() == 0) { 465 if (nanos <= 0) 466 return null; 467 nanos = notEmpty.awaitNanos(nanos); 468 } 469 x = dequeue(); 470 c = count.getAndDecrement(); 471 if (c > 1) 472 notEmpty.signal(); 473 } finally { 474 takeLock.unlock(); 475 } 476 if (c == capacity) 477 signalNotFull(); 478 return x; 479 } 480 481 public E poll() { 482 final AtomicInteger count = this.count; 483 if (count.get() == 0) 484 return null; 485 E x = null; 486 int c = -1; 487 final ReentrantLock takeLock = this.takeLock; 488 takeLock.lock(); 489 try { 490 if (count.get() > 0) { 491 x = dequeue(); 492 c = count.getAndDecrement(); 493 if (c > 1) 494 notEmpty.signal(); 495 } 496 } finally { 497 takeLock.unlock(); 498 } 499 if (c == capacity) 500 signalNotFull(); 501 return x; 502 } 503 504 public E peek() { 505 if (count.get() == 0) 506 return null; 507 final ReentrantLock takeLock = this.takeLock; 508 takeLock.lock(); 509 try { 510 Node<E> first = head.next; 511 if (first == null) 512 return null; 513 else 514 return first.item; 515 } finally { 516 takeLock.unlock(); 517 } 518 } 519 520 /** 521 * Unlinks interior Node p with predecessor trail. 522 */ 523 void unlink(Node<E> p, Node<E> trail) { 524 // assert isFullyLocked(); 525 // p.next is not changed, to allow iterators that are 526 // traversing p to maintain their weak-consistency guarantee. 527 p.item = null; 528 trail.next = p.next; 529 if (last == p) 530 last = trail; 531 if (count.getAndDecrement() == capacity) 532 notFull.signal(); 533 } 534 535 /** 536 * Removes a single instance of the specified element from this queue, 537 * if it is present. More formally, removes an element {@code e} such 538 * that {@code o.equals(e)}, if this queue contains one or more such 539 * elements. 540 * Returns {@code true} if this queue contained the specified element 541 * (or equivalently, if this queue changed as a result of the call). 542 * 543 * @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 545 */ 546 public boolean remove(Object o) { 547 if (o == null) return false; 548 fullyLock(); 549 try { 550 for (Node<E> trail = head, p = trail.next; 551 p != null; 552 trail = p, p = p.next) { 553 if (o.equals(p.item)) { 554 unlink(p, trail); 555 return true; 556 } 557 } 558 return false; 559 } finally { 560 fullyUnlock(); 561 } 562 } 563 564 /** 565 * Returns {@code true} if this queue contains the specified element. 566 * More formally, returns {@code true} if and only if this queue contains 567 * at least one element {@code e} such that {@code o.equals(e)}. 568 * 569 * @param o object to be checked for containment in this queue 570 * @return {@code true} if this queue contains the specified element 571 */ 572 public boolean contains(Object o) { 573 if (o == null) return false; 574 fullyLock(); 575 try { 576 for (Node<E> p = head.next; p != null; p = p.next) 577 if (o.equals(p.item)) 578 return true; 579 return false; 580 } finally { 581 fullyUnlock(); 582 } 583 } 584 585 /** 586 * Returns an array containing all of the elements in this queue, in 587 * proper sequence. 588 * 589 * <p>The returned array will be "safe" in that no references to it are 590 * maintained by this queue. (In other words, this method must allocate 591 * a new array). The caller is thus free to modify the returned array. 592 * 593 * <p>This method acts as bridge between array-based and collection-based 594 * APIs. 595 * 596 * @return an array containing all of the elements in this queue 597 */ 598 public Object[] toArray() { 599 fullyLock(); 600 try { 601 int size = count.get(); 602 Object[] a = new Object[size]; 603 int k = 0; 604 for (Node<E> p = head.next; p != null; p = p.next) 605 a[k++] = p.item; 606 return a; 607 } finally { 608 fullyUnlock(); 609 } 610 } 611 612 /** 613 * Returns an array containing all of the elements in this queue, in 614 * proper sequence; the runtime type of the returned array is that of 615 * the specified array. If the queue fits in the specified array, it 616 * is returned therein. Otherwise, a new array is allocated with the 617 * runtime type of the specified array and the size of this queue. 618 * 619 * <p>If this queue fits in the specified array with room to spare 620 * (i.e., the array has more elements than this queue), the element in 621 * the array immediately following the end of the queue is set to 622 * {@code null}. 623 * 624 * <p>Like the {@link #toArray()} method, this method acts as bridge between 625 * array-based and collection-based APIs. Further, this method allows 626 * precise control over the runtime type of the output array, and may, 627 * under certain circumstances, be used to save allocation costs. 628 * 629 * <p>Suppose {@code x} is a queue known to contain only strings. 630 * The following code can be used to dump the queue into a newly 631 * allocated array of {@code String}: 632 * 633 * <pre> 634 * String[] y = x.toArray(new String[0]);</pre> 635 * 636 * Note that {@code toArray(new Object[0])} is identical in function to 637 * {@code toArray()}. 638 * 639 * @param a the array into which the elements of the queue are to 640 * be stored, if it is big enough; otherwise, a new array of the 641 * same runtime type is allocated for this purpose 642 * @return an array containing all of the elements in this queue 643 * @throws ArrayStoreException if the runtime type of the specified array 644 * is not a supertype of the runtime type of every element in 645 * this queue 646 * @throws NullPointerException if the specified array is null 647 */ 648 @SuppressWarnings("unchecked") 649 public <T> T[] toArray(T[] a) { 650 fullyLock(); 651 try { 652 int size = count.get(); 653 if (a.length < size) 654 a = (T[])java.lang.reflect.Array.newInstance 655 (a.getClass().getComponentType(), size); 656 657 int k = 0; 658 for (Node<E> p = head.next; p != null; p = p.next) 659 a[k++] = (T)p.item; 660 if (a.length > k) 661 a[k] = null; 662 return a; 663 } finally { 664 fullyUnlock(); 665 } 666 } 667 668 public String toString() { 669 fullyLock(); 670 try { 671 Node<E> p = head.next; 672 if (p == null) 673 return "[]"; 674 Save This Page Home » openjdk-7 » java » util » concurrent » [javadoc | source] 1 /* 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This code is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 only, as 6 * published by the Free Software Foundation. Oracle designates this 7 * particular file as subject to the "Classpath" exception as provided 8 * by Oracle in the LICENSE file that accompanied this code. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25 /* 26 * This file is available under and governed by the GNU General Public 27 * License version 2 only, as published by the Free Software Foundation. 28 * However, the following notice accompanied the original version of this 29 * file: 30 * 31 * Written by Doug Lea with assistance from members of JCP JSR-166 32 * Expert Group and released to the public domain, as explained at 33 * http://creativecommons.org/publicdomain/zero/1.0/ 34 */ 35 36 package java.util.concurrent; 37 38 import java.util.concurrent.atomic.AtomicInteger; 39 import java.util.concurrent.locks.Condition; 40 import java.util.concurrent.locks.ReentrantLock; 41 import java.util.AbstractQueue; 42 import java.util.Collection; 43 import java.util.Iterator; 44 import java.util.NoSuchElementException; 45 46 /** 47 * An optionally-bounded {@linkplain BlockingQueue blocking queue} based on 48 * linked nodes. 49 * This queue orders elements FIFO (first-in-first-out). 50 * The <em>head</em> of the queue is that element that has been on the 51 * queue the longest time. 52 * The <em>tail</em> of the queue is that element that has been on the 53 * queue the shortest time. New elements 54 * are inserted at the tail of the queue, and the queue retrieval 55 * operations obtain elements at the head of the queue. 56 * Linked queues typically have higher throughput than array-based queues but 57 * less predictable performance in most concurrent applications. 58 * 59 * <p> The optional capacity bound constructor argument serves as a 60 * way to prevent excessive queue expansion. The capacity, if unspecified, 61 * is equal to {@link Integer#MAX_VALUE}. Linked nodes are 62 * dynamically created upon each insertion unless this would bring the 63 * queue above capacity. 64 * 65 * <p>This class and its iterator implement all of the 66 * <em>optional</em> methods of the {@link Collection} and {@link 67 * Iterator} interfaces. 68 * 69 * <p>This class is a member of the 70 * <a href="{@docRoot}/../technotes/guides/collections/index.html"> 71 * Java Collections Framework</a>. 72 * 73 * @since 1.5 74 * @author Doug Lea 75 * @param <E> the type of elements held in this collection 76 * 77 */ 78 public class LinkedBlockingQueue<E> extends AbstractQueue<E> 79 implements BlockingQueue<E>, java.io.Serializable { 80 private static final long serialVersionUID = -6903933977591709194L; 81 82 /* 83 * A variant of the "two lock queue" algorithm. The putLock gates 84 * entry to put (and offer), and has an associated condition for 85 * waiting puts. Similarly for the takeLock. The "count" field 86 * that they both rely on is maintained as an atomic to avoid 87 * needing to get both locks in most cases. Also, to minimize need 88 * for puts to get takeLock and vice-versa, cascading notifies are 89 * used. When a put notices that it has enabled at least one take, 90 * it signals taker. That taker in turn signals others if more 91 * items have been entered since the signal. And symmetrically for 92 * takes signalling puts. Operations such as remove(Object) and 93 * iterators acquire both locks. 94 * 95 * Visibility between writers and readers is provided as follows: 96 * 97 * Whenever an element is enqueued, the putLock is acquired and 98 * count updated. A subsequent reader guarantees visibility to the 99 * enqueued Node by either acquiring the putLock (via fullyLock) 100 * or by acquiring the takeLock, and then reading n = count.get(); 101 * this gives visibility to the first n items. 102 * 103 * To implement weakly consistent iterators, it appears we need to 104 * keep all Nodes GC-reachable from a predecessor dequeued Node. 105 * That would cause two problems: 106 * - allow a rogue Iterator to cause unbounded memory retention 107 * - cause cross-generational linking of old Nodes to new Nodes if 108 * a Node was tenured while live, which generational GCs have a 109 * hard time dealing with, causing repeated major collections. 110 * However, only non-deleted Nodes need to be reachable from 111 * dequeued Nodes, and reachability does not necessarily have to 112 * be of the kind understood by the GC. We use the trick of 113 * linking a Node that has just been dequeued to itself. Such a 114 * self-link implicitly means to advance to head.next. 115 */ 116 117 /** 118 * Linked list node class 119 */ 120 static class Node<E> { 121 E item; 122 123 /** 124 * One of: 125 * - the real successor Node 126 * - this Node, meaning the successor is head.next 127 * - null, meaning there is no successor (this is the last node) 128 */ 129 Node<E> next; 130 131 Node(E x) { item = x; } 132 } 133 134 /** The capacity bound, or Integer.MAX_VALUE if none */ 135 private final int capacity; 136 137 /** Current number of elements */ 138 private final AtomicInteger count = new AtomicInteger(0); 139 140 /** 141 * Head of linked list. 142 * Invariant: head.item == null 143 */ 144 private transient Node<E> head; 145 146 /** 147 * Tail of linked list. 148 * Invariant: last.next == null 149 */ 150 private transient Node<E> last; 151 152 /** Lock held by take, poll, etc */ 153 private final ReentrantLock takeLock = new ReentrantLock(); 154 155 /** Wait queue for waiting takes */ 156 private final Condition notEmpty = takeLock.newCondition(); 157 158 /** Lock held by put, offer, etc */ 159 private final ReentrantLock putLock = new ReentrantLock(); 160 161 /** Wait queue for waiting puts */ 162 private final Condition notFull = putLock.newCondition(); 163 164 /** 165 * Signals a waiting take. Called only from put/offer (which do not 166 * otherwise ordinarily lock takeLock.) 167 */ 168 private void signalNotEmpty() { 169 final ReentrantLock takeLock = this.takeLock; 170 takeLock.lock(); 171 try { 172 notEmpty.signal(); 173 } finally { 174 takeLock.unlock(); 175 } 176 } 177 178 /** 179 * Signals a waiting put. Called only from take/poll. 180 */ 181 private void signalNotFull() { 182 final ReentrantLock putLock = this.putLock; 183 putLock.lock(); 184 try { 185 notFull.signal(); 186 } finally { 187 putLock.unlock(); 188 } 189 } 190 191 /** 192 * Links node at end of queue. 193 * 194 * @param node the node 195 */ 196 private void enqueue(Node<E> node) { 197 // assert putLock.isHeldByCurrentThread(); 198 // assert last.next == null; 199 last = last.next = node; 200 } 201 202 /** 203 * Removes a node from head of queue. 204 * 205 * @return the node 206 */ 207 private E dequeue() { 208 // assert takeLock.isHeldByCurrentThread(); 209 // assert head.item == null; 210 Node<E> h = head; 211 Node<E> first = h.next; 212 h.next = h; // help GC 213 head = first; 214 E x = first.item; 215 first.item = null; 216 return x; 217 } 218 219 /** 220 * Lock to prevent both puts and takes. 221 */ 222 void fullyLock() { 223 putLock.lock(); 224 takeLock.lock(); 225 } 226 227 /** 228 * Unlock to allow both puts and takes. 229 */ 230 void fullyUnlock() { 231 takeLock.unlock(); 232 putLock.unlock(); 233 } 234 235 // /** 236 // * Tells whether both locks are held by current thread. 237 // */ 238 // boolean isFullyLocked() { 239 // return (putLock.isHeldByCurrentThread() && 240 // takeLock.isHeldByCurrentThread()); 241 // } 242 243 /** 244 * Creates a {@code LinkedBlockingQueue} with a capacity of 245 * {@link Integer#MAX_VALUE}. 246 */ 247 public LinkedBlockingQueue() { 248 this(Integer.MAX_VALUE); 249 } 250 251 /** 252 * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity. 253 * 254 * @param capacity the capacity of this queue 255 * @throws IllegalArgumentException if {@code capacity} is not greater 256 * than zero 257 */ 258 public LinkedBlockingQueue(int capacity) { 259 if (capacity <= 0) throw new IllegalArgumentException(); 260 this.capacity = capacity; 261 last = head = new Node<E>(null); 262 } 263 264 /** 265 * Creates a {@code LinkedBlockingQueue} with a capacity of 266 * {@link Integer#MAX_VALUE}, initially containing the elements of the 267 * given collection, 268 * added in traversal order of the collection's iterator. 269 * 270 * @param c the collection of elements to initially contain 271 * @throws NullPointerException if the specified collection or any 272 * of its elements are null 273 */ 274 public LinkedBlockingQueue(Collection<? extends E> c) { 275 this(Integer.MAX_VALUE); 276 final ReentrantLock putLock = this.putLock; 277 putLock.lock(); // Never contended, but necessary for visibility 278 try { 279 int n = 0; 280 for (E e : c) { 281 if (e == null) 282 throw new NullPointerException(); 283 if (n == capacity) 284 throw new IllegalStateException("Queue full"); 285 enqueue(new Node<E>(e)); 286 ++n; 287 } 288 count.set(n); 289 } finally { 290 putLock.unlock(); 291 } 292 } 293 294 295 // this doc comment is overridden to remove the reference to collections 296 // greater in size than Integer.MAX_VALUE 297 /** 298 * Returns the number of elements in this queue. 299 * 300 * @return the number of elements in this queue 301 */ 302 public int size() { 303 return count.get(); 304 } 305 306 // this doc comment is a modified copy of the inherited doc comment, 307 // without the reference to unlimited queues. 308 /** 309 * Returns the number of additional elements that this queue can ideally 310 * (in the absence of memory or resource constraints) accept without 311 * blocking. This is always equal to the initial capacity of this queue 312 * less the current {@code size} of this queue. 313 * 314 * <p>Note that you <em>cannot</em> always tell if an attempt to insert 315 * an element will succeed by inspecting {@code remainingCapacity} 316 * because it may be the case that another thread is about to 317 * insert or remove an element. 318 */ 319 public int remainingCapacity() { 320 return capacity - count.get(); 321 } 322 323 /** 324 * Inserts the specified element at the tail of this queue, waiting if 325 * necessary for space to become available. 326 * 327 * @throws InterruptedException {@inheritDoc} 328 * @throws NullPointerException {@inheritDoc} 329 */ 330 public void put(E e) throws InterruptedException { 331 if (e == null) throw new NullPointerException(); 332 // Note: convention in all put/take/etc is to preset local var 333 // holding count negative to indicate failure unless set. 334 int c = -1; 335 Node<E> node = new Node(e); 336 final ReentrantLock putLock = this.putLock; 337 final AtomicInteger count = this.count; 338 putLock.lockInterruptibly(); 339 try {
skanev
marcelgsantos
javiergs
nashiusagi
dropout009
andpad
maroon1st
rainerhahnekamp
h0r15h0
kwakeuijin
daisukeshinoku
chrisbanes
okuzawats
lauravandoore
jacobian
holman
smashingmag
gr2m
bkeepers
eileencodes
keithpitt
mza
danielanewman
chrisshort
csswizardry
![Game of Life (defn neighbours [[x y]] (for [dx [-1](https://files.speakerdeck.com/presentations/7ace6f2064210130f08a12313d04fda1/slide_47.jpg){kind=link}
