hippo4j-develop.zip

/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package cn.hippo4j.common.executor.support; import java.util.AbstractQueue; import java.util.Collection; import java.util.Iterator; import java.util.NoSuchElementException; import java.util.concurrent.BlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; /** * A clone of {@linkplain java.util.concurrent.LinkedBlockingQueue} * with the addition of a {@link #setCapacity(int)} method, allowing us to * change the capacity of the queue while it is in use.<p> * <p> * The documentation for LinkedBlockingQueue follows...<p> * <p> * 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. * * <p> The optional capacity bound constructor argument serves as a * 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 implements 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}/../guide/collections/index.html"> * Java Collections Framework</a>. * * @param <E> the type of elements held in this collection * @author Doug Lea * @since 1.5 **/ public class ResizableCapacityLinkedBlockingQueue<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. */ /** * Linked list node class */ static class Node<E> { /** * The item, volatile to ensure barrier separating write and read */ volatile E item; Node<E> next; Node(E x) { item = x; } } /** * The capacity bound, or Integer.MAX_VALUE if none */ private int capacity; /** * Current number of elements */ private final AtomicInteger count = new AtomicInteger(0); /** * Head of linked list */ private transient Node<E> head; /** * Tail of linked list */ 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(); /** * Signal 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(); } } /** * Signal a waiting put. Called only from take/poll. */ private void signalNotFull() { final ReentrantLock putLock = this.putLock; putLock.lock(); try { notFull.signal(); } finally { putLock.unlock(); } } /** * Create a node and link it at end of queue * * @param x the item */ private void insert(E x) { last = last.next = new Node<E>(x); } /** * Remove a node from head of queue, * * @return the node */ private E extract() { Node<E> first = head.next; head = first; E x = first.item; first.item = null; return x; } /** * Lock to prevent both puts and takes. */ private void fullyLock() { putLock.lock(); takeLock.lock(); } /** * Unlock to allow both puts and takes. */ private void fullyUnlock() { takeLock.unlock(); putLock.unlock(); } /** * Creates a <tt>LinkedBlockingQueue</tt> with a capacity of * {@link Integer#MAX_VALUE}. */ public ResizableCapacityLinkedBlockingQueue() { this(Integer.MAX_VALUE); } /** * Creates a <tt>LinkedBlockingQueue</tt> with the given (fixed) capacity. * * @param capacity the capacity of this queue. * @throws IllegalArgumentException if <tt>capacity</tt> is not greater * than zero. */ public ResizableCapacityLinkedBlockingQueue(int capacity) { if (capacity <= 0) { throw new IllegalArgumentException(); } this.capacity = capacity; last = head = new Node<E>(null); } /** * Creates a <tt>LinkedBlockingQueue</tt> with a capacity of * {@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 <tt>c</tt> or any element within it * is <tt>null</tt> */ public ResizableCapacityLinkedBlockingQueue(Collection<? extends E> c) { this(Integer.MAX_VALUE); for (Iterator<? extends E> it = c.iterator(); it.hasNext();) { add(it.next()); } } // 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. */ @Override public int size() { return count.get(); } /** * Set a new capacity for the queue. Increasing the capacity can * cau