[jboss-remoting-commits] JBoss Remoting SVN: r4852 - in remoting3/trunk: core/src/main/java/org/jboss/remoting/core/util and 1 other directories.

Author: david.lloyd(a)jboss.com Date: 2009-02-25 21:44:32 -0500 (Wed, 25 Feb 2009) New Revision: 4852 Added: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ConcurrentReferenceHashMap.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/OrderedExecutor.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/QueueExecutor.java Removed: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/AtomicMap.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/CollectionUtil.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/ConcurrentReferenceHashMap.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/DecodingBuilder.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/NamingThreadFactory.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutor.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutorFactory.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/QueueExecutor.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedCollection.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedIterator.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedMap.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedQueue.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedSet.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/WeakHashSet.java Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/AbstractContextImpl.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientImpl.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientSourceImpl.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/EndpointImpl.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/FutureReplyImpl.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/LocalRequestHandler.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestContextImpl.java remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestListenerExecutor.java remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexClientExample.java remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexServerExample.java Log: Big cleanup Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/AbstractContextImpl.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/AbstractContextImpl.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/AbstractContextImpl.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -22,17 +22,17 @@ package org.jboss.remoting.core; +import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.Executor; import org.jboss.remoting.spi.AbstractHandleableCloseable; -import org.jboss.remoting.core.util.CollectionUtil; /** * */ public abstract class AbstractContextImpl<T> extends AbstractHandleableCloseable<T> { - private final ConcurrentMap<Object, Object> attributes = CollectionUtil.concurrentMap(); + private final ConcurrentMap<Object, Object> attributes = new ConcurrentHashMap<Object, Object>(); protected AbstractContextImpl(final Executor executor) { super(executor); Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientImpl.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientImpl.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientImpl.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -25,10 +25,10 @@ import java.io.IOException; import java.util.concurrent.Executor; import org.jboss.remoting.Client; +import org.jboss.remoting.CloseHandler; import org.jboss.remoting.IndeterminateOutcomeException; import org.jboss.remoting.RemoteRequestException; -import org.jboss.remoting.CloseHandler; -import org.jboss.remoting.core.util.QueueExecutor; +import org.jboss.remoting.core.QueueExecutor; import org.jboss.remoting.spi.Handle; import org.jboss.remoting.spi.RemoteRequestContext; import org.jboss.remoting.spi.ReplyHandler; Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientSourceImpl.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientSourceImpl.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ClientSourceImpl.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -25,8 +25,8 @@ import java.io.IOException; import org.jboss.remoting.Client; import org.jboss.remoting.ClientSource; +import org.jboss.remoting.CloseHandler; import org.jboss.remoting.Endpoint; -import org.jboss.remoting.CloseHandler; import org.jboss.remoting.spi.AbstractHandleableCloseable; import org.jboss.remoting.spi.Handle; import org.jboss.remoting.spi.RequestHandler; Copied: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ConcurrentReferenceHashMap.java (from rev 4847, remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/ConcurrentReferenceHashMap.java) =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ConcurrentReferenceHashMap.java (rev 0) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/ConcurrentReferenceHashMap.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -0,0 +1,1709 @@ +/* + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/licenses/publicdomain + */ + +package org.jboss.remoting.core; +import java.io.IOException; +import java.io.Serializable; +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; +import java.lang.ref.WeakReference; +import java.util.AbstractCollection; +import java.util.AbstractMap; +import java.util.AbstractSet; +import java.util.Collection; +import java.util.ConcurrentModificationException; +import java.util.EnumSet; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Hashtable; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.concurrent.locks.ReentrantLock; + +/** + * An advanced hash table supporting configurable garbage collection semantics + * of keys and values, optional referential-equality, full concurrency of + * retrievals, and adjustable expected concurrency for updates. + * + * This table is designed around specific advanced use-cases. If there is any + * doubt whether this table is for you, you most likely should be using + * {@link java.util.concurrent.ConcurrentHashMap} instead. + * + * This table supports strong, weak, and soft keys and values. By default keys + * are weak, and values are strong. Such a configuration offers similar behavior + * to {@link java.util.WeakHashMap}, entries of this table are periodically + * removed once their corresponding keys are no longer referenced outside of + * this table. In other words, this table will not prevent a key from being + * discarded by the garbage collector. Once a key has been discarded by the + * collector, the corresponding entry is no longer visible to this table; + * however, the entry may occupy space until a future table operation decides to + * reclaim it. For this reason, summary functions such as <tt>size</tt> and + * <tt>isEmpty</tt> might return a value greater than the observed number of + * entries. In order to support a high level of concurrency, stale entries are + * only reclaimed during blocking (usually mutating) operations. + * + * Enabling soft keys allows entries in this table to remain until their space + * is absolutely needed by the garbage collector. This is unlike weak keys which + * can be reclaimed as soon as they are no longer referenced by a normal strong + * reference. The primary use case for soft keys is a cache, which ideally + * occupies memory that is not in use for as long as possible. + * + * By default, values are held using a normal strong reference. This provides + * the commonly desired guarantee that a value will always have at least the + * same life-span as it's key. For this reason, care should be taken to ensure + * that a value never refers, either directly or indirectly, to its key, thereby + * preventing reclamation. If this is unavoidable, then it is recommended to use + * the same reference type in use for the key. However, it should be noted that + * non-strong values may disappear before their corresponding key. + * + * While this table does allow the use of both strong keys and values, it is + * recommended to use {@link java.util.concurrent.ConcurrentHashMap} for such a + * configuration, since it is optimized for that case. + * + * Just like {@link java.util.concurrent.ConcurrentHashMap}, this class obeys + * the same functional specification as {@link java.util.Hashtable}, and + * includes versions of methods corresponding to each method of + * <tt>Hashtable</tt>. However, even though all operations are thread-safe, + * retrieval operations do <em>not</em> entail locking, and there is + * <em>not</em> any support for locking the entire table in a way that + * prevents all access. This class is fully interoperable with + * <tt>Hashtable</tt> in programs that rely on its thread safety but not on + * its synchronization details. + * + * <p> + * Retrieval operations (including <tt>get</tt>) generally do not block, so + * may overlap with update operations (including <tt>put</tt> and + * <tt>remove</tt>). Retrievals reflect the results of the most recently + * <em>completed</em> update operations holding upon their onset. For + * aggregate operations such as <tt>putAll</tt> and <tt>clear</tt>, + * concurrent retrievals may reflect insertion or removal of only some entries. + * Similarly, Iterators and Enumerations return elements reflecting the state of + * the hash table at some point at or since the creation of the + * iterator/enumeration. They do <em>not</em> throw + * {@link ConcurrentModificationException}. However, iterators are designed to + * be used by only one thread at a time. + * + * <p> + * The allowed concurrency among update operations is guided by the optional + * <tt>concurrencyLevel</tt> constructor argument (default <tt>16</tt>), + * which is used as a hint for internal sizing. The table is internally + * partitioned to try to permit the indicated number of concurrent updates + * without contention. Because placement in hash tables is essentially random, + * the actual concurrency will vary. Ideally, you should choose a value to + * accommodate as many threads as will ever concurrently modify the table. Using + * a significantly higher value than you need can waste space and time, and a + * significantly lower value can lead to thread contention. But overestimates + * and underestimates within an order of magnitude do not usually have much + * noticeable impact. A value of one is appropriate when it is known that only + * one thread will modify and all others will only read. Also, resizing this or + * any other kind of hash table is a relatively slow operation, so, when + * possible, it is a good idea to provide estimates of expected table sizes in + * constructors. + * + * <p> + * This class and its views and iterators implement all of the <em>optional</em> + * methods of the {@link Map} and {@link Iterator} interfaces. + * + * <p> + * Like {@link Hashtable} but unlike {@link HashMap}, this class does + * <em>not</em> allow <tt>null</tt> to be used as a key or value. + * + * <p> + * This class is a member of the <a href="{@docRoot}/../technotes/guides/collections/index.html"> + * Java Collections Framework</a>. + * + * @author Doug Lea + * @author Jason T. Greene + * @param <K> the type of keys maintained by this map + * @param <V> the type of mapped values + */ +public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V> + implements java.util.concurrent.ConcurrentMap<K, V>, Serializable { + private static final long serialVersionUID = 7249069246763182397L; + + /* + * The basic strategy is to subdivide the table among Segments, + * each of which itself is a concurrently readable hash table. + */ + + /** + * An option specifying which Java reference type should be used to refer + * to a key and/or value. + */ + public static enum ReferenceType { + /** Indicates a normal Java strong reference should be used */ + STRONG, + /** Indicates a {@link WeakReference} should be used */ + WEAK, + /** Indicates a {@link SoftReference} should be used */ + SOFT + }; + + + public static enum Option { + /** Indicates that referential-equality (== instead of .equals()) should + * be used when locating keys. This offers similar behavior to {@link IdentityHashMap} */ + IDENTITY_COMPARISONS + }; + + /* ---------------- Constants -------------- */ + + static final ReferenceType DEFAULT_KEY_TYPE = ReferenceType.WEAK; + + static final ReferenceType DEFAULT_VALUE_TYPE = ReferenceType.STRONG; + + + /** + * The default initial capacity for this table, + * used when not otherwise specified in a constructor. + */ + static final int DEFAULT_INITIAL_CAPACITY = 16; + + /** + * The default load factor for this table, used when not + * otherwise specified in a constructor. + */ + static final float DEFAULT_LOAD_FACTOR = 0.75f; + + /** + * The default concurrency level for this table, used when not + * otherwise specified in a constructor. + */ + static final int DEFAULT_CONCURRENCY_LEVEL = 16; + + /** + * The maximum capacity, used if a higher value is implicitly + * specified by either of the constructors with arguments. MUST + * be a power of two <= 1<<30 to ensure that entries are indexable + * using ints. + */ + static final int MAXIMUM_CAPACITY = 1 << 30; + + /** + * The maximum number of segments to allow; used to bound + * constructor arguments. + */ + static final int MAX_SEGMENTS = 1 << 16; // slightly conservative + + /** + * Number of unsynchronized retries in size and containsValue + * methods before resorting to locking. This is used to avoid + * unbounded retries if tables undergo continuous modification + * which would make it impossible to obtain an accurate result. + */ + static final int RETRIES_BEFORE_LOCK = 2; + + /* ---------------- Fields -------------- */ + + /** + * Mask value for indexing into segments. The upper bits of a + * key's hash code are used to choose the segment. + */ + final int segmentMask; + + /** + * Shift value for indexing within segments. + */ + final int segmentShift; + + /** + * The segments, each of which is a specialized hash table + */ + final Segment<K,V>[] segments; + + boolean identityComparisons; + + transient Set<K> keySet; + transient Set<Map.Entry<K,V>> entrySet; + transient Collection<V> values; + + /* ---------------- Small Utilities -------------- */ + + /** + * Applies a supplemental hash function to a given hashCode, which + * defends against poor quality hash functions. This is critical + * because ConcurrentReferenceHashMap uses power-of-two length hash tables, + * that otherwise encounter collisions for hashCodes that do not + * differ in lower or upper bits. + */ + private static int hash(int h) { + // Spread bits to regularize both segment and index locations, + // using variant of single-word Wang/Jenkins hash. + h += (h << 15) ^ 0xffffcd7d; + h ^= (h >>> 10); + h += (h << 3); + h ^= (h >>> 6); + h += (h << 2) + (h << 14); + return h ^ (h >>> 16); + } + + /** + * Returns the segment that should be used for key with given hash + * @param hash the hash code for the key + * @return the segment + */ + final Segment<K,V> segmentFor(int hash) { + return segments[(hash >>> segmentShift) & segmentMask]; + } + + private int hashOf(Object key) { + return hash(identityComparisons ? + System.identityHashCode(key) : key.hashCode()); + } + + /* ---------------- Inner Classes -------------- */ + + static interface KeyReference { + int keyHash(); + Object keyRef(); + } + + /** + * A weak-key reference which stores the key hash needed for reclamation. + */ + static final class WeakKeyReference<K> extends WeakReference<K> implements KeyReference { + final int hash; + WeakKeyReference(K key, int hash, ReferenceQueue<Object> refQueue) { + super(key, refQueue); + this.hash = hash; + } + public final int keyHash() { + return hash; + } + + public final Object keyRef() { + return this; + } + } + + /** + * A soft-key reference which stores the key hash needed for reclamation. + */ + static final class SoftKeyReference<K> extends SoftReference<K> implements KeyReference { + final int hash; + SoftKeyReference(K key, int hash, ReferenceQueue<Object> refQueue) { + super(key, refQueue); + this.hash = hash; + } + public final int keyHash() { + return hash; + } + + public final Object keyRef() { + return this; + } + } + + static final class WeakValueReference<V> extends WeakReference<V> implements KeyReference { + final Object keyRef; + final int hash; + WeakValueReference(V value, Object keyRef, int hash, ReferenceQueue<Object> refQueue) { + super(value, refQueue); + this.keyRef = keyRef; + this.hash = hash; + } + + public final int keyHash() { + return hash; + } + + public final Object keyRef() { + return keyRef; + } + } + + static final class SoftValueReference<V> extends SoftReference<V> implements KeyReference { + final Object keyRef; + final int hash; + SoftValueReference(V value, Object keyRef, int hash, ReferenceQueue<Object> refQueue) { + super(value, refQueue); + this.keyRef = keyRef; + this.hash = hash; + } + public final int keyHash() { + return hash; + } + + public final Object keyRef() { + return keyRef; + } + } + + /** + * ConcurrentReferenceHashMap list entry. Note that this is never exported + * out as a user-visible Map.Entry. + * + * Because the value field is volatile, not final, it is legal wrt + * the Java Memory Model for an unsynchronized reader to see null + * instead of initial value when read via a data race. Although a + * reordering leading to this is not likely to ever actually + * occur, the Segment.readValueUnderLock method is used as a + * backup in case a null (pre-initialized) value is ever seen in + * an unsynchronized access method. + */ + static final class HashEntry<K,V> { + final Object keyRef; + final int hash; + volatile Object valueRef; + final HashEntry<K,V> next; + + HashEntry(K key, int hash, HashEntry<K,V> next, V value, + ReferenceType keyType, ReferenceType valueType, + ReferenceQueue<Object> refQueue) { + this.hash = hash; + this.next = next; + this.keyRef = newKeyReference(key, keyType, refQueue); + this.valueRef = newValueReference(value, valueType, refQueue); + } + + final Object newKeyReference(K key, ReferenceType keyType, + ReferenceQueue<Object> refQueue) { + if (keyType == ReferenceType.WEAK) + return new WeakKeyReference<K>(key, hash, refQueue); + if (keyType == ReferenceType.SOFT) + return new SoftKeyReference<K>(key, hash, refQueue); + + return key; + } + + final Object newValueReference(V value, ReferenceType valueType, + ReferenceQueue<Object> refQueue) { + if (valueType == ReferenceType.WEAK) + return new WeakValueReference<V>(value, keyRef, hash, refQueue); + if (valueType == ReferenceType.SOFT) + return new SoftValueReference<V>(value, keyRef, hash, refQueue); + + return value; + } + + @SuppressWarnings("unchecked") + final K key() { + if (keyRef instanceof Reference) + return ((Reference<K>)keyRef).get(); + + return (K) keyRef; + } + + final V value() { + return dereferenceValue(valueRef); + } + + @SuppressWarnings("unchecked") + final V dereferenceValue(Object value) { + if (value instanceof Reference) + return ((Reference<V>)value).get(); + + return (V) value; + } + + final void setValue(V value, ReferenceType valueType, ReferenceQueue<Object> refQueue) { + this.valueRef = newValueReference(value, valueType, refQueue); + } + + @SuppressWarnings("unchecked") + static final <K,V> HashEntry<K,V>[] newArray(int i) { + return new HashEntry[i]; + } + } + + /** + * Segments are specialized versions of hash tables. This + * subclasses from ReentrantLock opportunistically, just to + * simplify some locking and avoid separate construction. + */ + static final class Segment<K,V> extends ReentrantLock implements Serializable { + /* + * Segments maintain a table of entry lists that are ALWAYS + * kept in a consistent state, so can be read without locking. + * Next fields of nodes are immutable (final). All list + * additions are performed at the front of each bin. This + * makes it easy to check changes, and also fast to traverse. + * When nodes would otherwise be changed, new nodes are + * created to replace them. This works well for hash tables + * since the bin lists tend to be short. (The average length + * is less than two for the default load factor threshold.) + * + * Read operations can thus proceed without locking, but rely + * on selected uses of volatiles to ensure that completed + * write operations performed by other threads are + * noticed. For most purposes, the "count" field, tracking the + * number of elements, serves as that volatile variable + * ensuring visibility. This is convenient because this field + * needs to be read in many read operations anyway: + * + * - All (unsynchronized) read operations must first read the + * "count" field, and should not look at table entries if + * it is 0. + * + * - All (synchronized) write operations should write to + * the "count" field after structurally changing any bin. + * The operations must not take any action that could even + * momentarily cause a concurrent read operation to see + * inconsistent data. This is made easier by the nature of + * the read operations in Map. For example, no operation + * can reveal that the table has grown but the threshold + * has not yet been updated, so there are no atomicity + * requirements for this with respect to reads. + * + * As a guide, all critical volatile reads and writes to the + * count field are marked in code comments. + */ + + private static final long serialVersionUID = 2249069246763182397L; + + /** + * The number of elements in this segment's region. + */ + transient volatile int count; + + /** + * Number of updates that alter the size of the table. This is + * used during bulk-read methods to make sure they see a + * consistent snapshot: If modCounts change during a traversal + * of segments computing size or checking containsValue, then + * we might have an inconsistent view of state so (usually) + * must retry. + */ + transient int modCount; + + /** + * The table is rehashed when its size exceeds this threshold. + * (The value of this field is always <tt>(int)(capacity * + * loadFactor)</tt>.) + */ + transient int threshold; + + /** + * The per-segment table. + */ + transient volatile HashEntry<K,V>[] table; + + /** + * The load factor for the hash table. Even though this value + * is same for all segments, it is replicated to avoid needing + * links to outer object. + * @serial + */ + final float loadFactor; + + /** + * The collected weak-key reference queue for this segment. + * This should be (re)initialized whenever table is assigned, + */ + transient volatile ReferenceQueue<Object> refQueue; + + final ReferenceType keyType; + + final ReferenceType valueType; + + final boolean identityComparisons; + + Segment(int initialCapacity, float lf, ReferenceType keyType, + ReferenceType valueType, boolean identityComparisons) { + loadFactor = lf; + this.keyType = keyType; + this.valueType = valueType; + this.identityComparisons = identityComparisons; + setTable(HashEntry.<K,V>newArray(initialCapacity)); + } + + @SuppressWarnings("unchecked") + static final <K,V> Segment<K,V>[] newArray(int i) { + return new Segment[i]; + } + + private boolean keyEq(Object src, Object dest) { + return identityComparisons ? src == dest : src.equals(dest); + } + + /** + * Sets table to new HashEntry array. + * Call only while holding lock or in constructor. + */ + void setTable(HashEntry<K,V>[] newTable) { + threshold = (int)(newTable.length * loadFactor); + table = newTable; + refQueue = new ReferenceQueue<Object>(); + } + + /** + * Returns properly casted first entry of bin for given hash. + */ + HashEntry<K,V> getFirst(int hash) { + HashEntry<K,V>[] tab = table; + return tab[hash & (tab.length - 1)]; + } + + HashEntry<K,V> newHashEntry(K key, int hash, HashEntry<K, V> next, V value) { + return new HashEntry<K,V>(key, hash, next, value, keyType, valueType, refQueue); + } + + /** + * Reads value field of an entry under lock. Called if value + * field ever appears to be null. This is possible only if a + * compiler happens to reorder a HashEntry initialization with + * its table assignment, which is legal under memory model + * but is not known to ever occur. + */ + V readValueUnderLock(HashEntry<K,V> e) { + lock(); + try { + removeStale(); + return e.value(); + } finally { + unlock(); + } + } + + /* Specialized implementations of map methods */ + + V get(Object key, int hash) { + if (count != 0) { // read-volatile + HashEntry<K,V> e = getFirst(hash); + while (e != null) { + if (e.hash == hash && keyEq(key, e.key())) { + Object opaque = e.valueRef; + if (opaque != null) + return e.dereferenceValue(opaque); + + return readValueUnderLock(e); // recheck + } + e = e.next; + } + } + return null; + } + + boolean containsKey(Object key, int hash) { + if (count != 0) { // read-volatile + HashEntry<K,V> e = getFirst(hash); + while (e != null) { + if (e.hash == hash && keyEq(key, e.key())) + return true; + e = e.next; + } + } + return false; + } + + boolean containsValue(Object value) { + if (count != 0) { // read-volatile + HashEntry<K,V>[] tab = table; + int len = tab.length; + for (int i = 0 ; i < len; i++) { + for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) { + Object opaque = e.valueRef; + V v; + + if (opaque == null) + v = readValueUnderLock(e); // recheck + else + v = e.dereferenceValue(opaque); + + if (value.equals(v)) + return true; + } + } + } + return false; + } + + boolean replace(K key, int hash, V oldValue, V newValue) { + lock(); + try { + removeStale(); + HashEntry<K,V> e = getFirst(hash); + while (e != null && (e.hash != hash || !keyEq(key, e.key()))) + e = e.next; + + boolean replaced = false; + if (e != null && oldValue.equals(e.value())) { + replaced = true; + e.setValue(newValue, valueType, refQueue); + } + return replaced; + } finally { + unlock(); + } + } + + V replace(K key, int hash, V newValue) { + lock(); + try { + removeStale(); + HashEntry<K,V> e = getFirst(hash); + while (e != null && (e.hash != hash || !keyEq(key, e.key()))) + e = e.next; + + V oldValue = null; + if (e != null) { + oldValue = e.value(); + e.setValue(newValue, valueType, refQueue); + } + return oldValue; + } finally { + unlock(); + } + } + + + V put(K key, int hash, V value, boolean onlyIfAbsent) { + lock(); + try { + removeStale(); + int c = count; + if (c++ > threshold) {// ensure capacity + int reduced = rehash(); + if (reduced > 0) // adjust from possible weak cleanups + count = (c -= reduced) - 1; // write-volatile + } + + HashEntry<K,V>[] tab = table; + int index = hash & (tab.length - 1); + HashEntry<K,V> first = tab[index]; + HashEntry<K,V> e = first; + while (e != null && (e.hash != hash || !keyEq(key, e.key()))) + e = e.next; + + V oldValue; + if (e != null) { + oldValue = e.value(); + if (!onlyIfAbsent) + e.setValue(value, valueType, refQueue); + } + else { + oldValue = null; + ++modCount; + tab[index] = newHashEntry(key, hash, first, value); + count = c; // write-volatile + } + return oldValue; + } finally { + unlock(); + } + } + + int rehash() { + HashEntry<K,V>[] oldTable = table; + int oldCapacity = oldTable.length; + if (oldCapacity >= MAXIMUM_CAPACITY) + return 0; + + /* + * Reclassify nodes in each list to new Map. Because we are + * using power-of-two expansion, the elements from each bin + * must either stay at same index, or move with a power of two + * offset. We eliminate unnecessary node creation by catching + * cases where old nodes can be reused because their next + * fields won't change. Statistically, at the default + * threshold, only about one-sixth of them need cloning when + * a table doubles. The nodes they replace will be garbage + * collectable as soon as they are no longer referenced by any + * reader thread that may be in the midst of traversing table + * right now. + */ + + HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1); + threshold = (int)(newTable.length * loadFactor); + int sizeMask = newTable.length - 1; + int reduce = 0; + for (int i = 0; i < oldCapacity ; i++) { + // We need to guarantee that any existing reads of old Map can + // proceed. So we cannot yet null out each bin. + HashEntry<K,V> e = oldTable[i]; + + if (e != null) { + HashEntry<K,V> next = e.next; + int idx = e.hash & sizeMask; + + // Single node on list + if (next == null) + newTable[idx] = e; + + else { + // Reuse trailing consecutive sequence at same slot + HashEntry<K,V> lastRun = e; + int lastIdx = idx; + for (HashEntry<K,V> last = next; + last != null; + last = last.next) { + int k = last.hash & sizeMask; + if (k != lastIdx) { + lastIdx = k; + lastRun = last; + } + } + newTable[lastIdx] = lastRun; + // Clone all remaining nodes + for (HashEntry<K,V> p = e; p != lastRun; p = p.next) { + // Skip GC'd weak refs + K key = p.key(); + if (key == null) { + reduce++; + continue; + } + int k = p.hash & sizeMask; + HashEntry<K,V> n = newTable[k]; + newTable[k] = newHashEntry(key, p.hash, n, p.value()); + } + } + } + } + table = newTable; + return reduce; + } + + /** + * Remove; match on key only if value null, else match both. + */ + V remove(Object key, int hash, Object value, boolean refRemove) { + lock(); + try { + if (!refRemove) + removeStale(); + int c = count - 1; + HashEntry<K,V>[] tab = table; + int index = hash & (tab.length - 1); + HashEntry<K,V> first = tab[index]; + HashEntry<K,V> e = first; + // a ref remove operation compares the Reference instance + while (e != null && key != e.keyRef + && (refRemove || hash != e.hash || !keyEq(key, e.key()))) + e = e.next; + + V oldValue = null; + if (e != null) { + V v = e.value(); + if (value == null || value.equals(v)) { + oldValue = v; + // All entries following removed node can stay + // in list, but all preceding ones need to be + // cloned. + ++modCount; + HashEntry<K,V> newFirst = e.next; + for (HashEntry<K,V> p = first; p != e; p = p.next) { + K pKey = p.key(); + if (pKey == null) { // Skip GC'd keys + c--; + continue; + } + + newFirst = newHashEntry(pKey, p.hash, newFirst, p.value()); + } + tab[index] = newFirst; + count = c; // write-volatile + } + } + return oldValue; + } finally { + unlock(); + } + } + + final void removeStale() { + KeyReference ref; + while ((ref = (KeyReference) refQueue.poll()) != null) { + remove(ref.keyRef(), ref.keyHash(), null, true); + } + } + + void clear() { + if (count != 0) { + lock(); + try { + HashEntry<K,V>[] tab = table; + for (int i = 0; i < tab.length ; i++) + tab[i] = null; + ++modCount; + // replace the reference queue to avoid unnecessary stale cleanups + refQueue = new ReferenceQueue<Object>(); + count = 0; // write-volatile + } finally { + unlock(); + } + } + } + } + + + + /* ---------------- Public operations -------------- */ + + /** + * Creates a new, empty map with the specified initial + * capacity, reference types, load factor and concurrency level. + * + * Behavioral changing options such as {@link Option#IDENTITY_COMPARISONS} + * can also be specified. + * + * @param initialCapacity the initial capacity. The implementation + * performs internal sizing to accommodate this many elements. + * @param loadFactor the load factor threshold, used to control resizing. + * Resizing may be performed when the average number of elements per + * bin exceeds this threshold. + * @param concurrencyLevel the estimated number of concurrently + * updating threads. The implementation performs internal sizing + * to try to accommodate this many threads. + * @param keyType the reference type to use for keys + * @param valueType the reference type to use for values + * @param options the behavioral options + * @throws IllegalArgumentException if the initial capacity is + * negative or the load factor or concurrencyLevel are + * nonpositive. + */ + public ConcurrentReferenceHashMap(int initialCapacity, + float loadFactor, int concurrencyLevel, + ReferenceType keyType, ReferenceType valueType, + EnumSet<Option> options) { + if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) + throw new IllegalArgumentException(); + + if (concurrencyLevel > MAX_SEGMENTS) + concurrencyLevel = MAX_SEGMENTS; + + // Find power-of-two sizes best matching arguments + int sshift = 0; + int ssize = 1; + while (ssize < concurrencyLevel) { + ++sshift; + ssize <<= 1; + } + segmentShift = 32 - sshift; + segmentMask = ssize - 1; + this.segments = Segment.newArray(ssize); + + if (initialCapacity > MAXIMUM_CAPACITY) + initialCapacity = MAXIMUM_CAPACITY; + int c = initialCapacity / ssize; + if (c * ssize < initialCapacity) + ++c; + int cap = 1; + while (cap < c) + cap <<= 1; + + identityComparisons = options != null && options.contains(Option.IDENTITY_COMPARISONS); + + for (int i = 0; i < this.segments.length; ++i) + this.segments[i] = new Segment<K,V>(cap, loadFactor, + keyType, valueType, identityComparisons); + } + + /** + * Creates a new, empty map with the specified initial + * capacity, load factor and concurrency level. + * + * @param initialCapacity the initial capacity. The implementation + * performs internal sizing to accommodate this many elements. + * @param loadFactor the load factor threshold, used to control resizing. + * Resizing may be performed when the average number of elements per + * bin exceeds this threshold. + * @param concurrencyLevel the estimated number of concurrently + * updating threads. The implementation performs internal sizing + * to try to accommodate this many threads. + * @throws IllegalArgumentException if the initial capacity is + * negative or the load factor or concurrencyLevel are + * nonpositive. + */ + public ConcurrentReferenceHashMap(int initialCapacity, + float loadFactor, int concurrencyLevel) { + this(initialCapacity, loadFactor, concurrencyLevel, + DEFAULT_KEY_TYPE, DEFAULT_VALUE_TYPE, null); + } + + /** + * Creates a new, empty map with the specified initial capacity + * and load factor and with the default reference types (weak keys, + * strong values), and concurrencyLevel (16). + * + * @param initialCapacity The implementation performs internal + * sizing to accommodate this many elements. + * @param loadFactor the load factor threshold, used to control resizing. + * Resizing may be performed when the average number of elements per + * bin exceeds this threshold. + * @throws IllegalArgumentException if the initial capacity of + * elements is negative or the load factor is nonpositive + * + * @since 1.6 + */ + public ConcurrentReferenceHashMap(int initialCapacity, float loadFactor) { + this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL); + } + + + /** + * Creates a new, empty map with the specified initial capacity, + * reference types and with default load factor (0.75) and concurrencyLevel (16). + * + * @param initialCapacity the initial capacity. The implementation + * performs internal sizing to accommodate this many elements. + * @param keyType the reference type to use for keys + * @param valueType the reference type to use for values + * @throws IllegalArgumentException if the initial capacity of + * elements is negative. + */ + public ConcurrentReferenceHashMap(int initialCapacity, + ReferenceType keyType, ReferenceType valueType) { + this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL, + keyType, valueType, null); + } + + /** + * Creates a new, empty map with the specified initial capacity, + * and with default reference types (weak keys, strong values), + * load factor (0.75) and concurrencyLevel (16). + * + * @param initialCapacity the initial capacity. The implementation + * performs internal sizing to accommodate this many elements. + * @throws IllegalArgumentException if the initial capacity of + * elements is negative. + */ + public ConcurrentReferenceHashMap(int initialCapacity) { + this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); + } + + /** + * Creates a new, empty map with a default initial capacity (16), + * reference types (weak keys, strong values), default + * load factor (0.75) and concurrencyLevel (16). + */ + public ConcurrentReferenceHashMap() { + this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); + } + + /** + * Creates a new map with the same mappings as the given map. + * The map is created with a capacity of 1.5 times the number + * of mappings in the given map or 16 (whichever is greater), + * and a default load factor (0.75) and concurrencyLevel (16). + * + * @param m the map + */ + public ConcurrentReferenceHashMap(Map<? extends K, ? extends V> m) { + this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, + DEFAULT_INITIAL_CAPACITY), + DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); + putAll(m); + } + + /** + * Returns <tt>true</tt> if this map contains no key-value mappings. + * + * @return <tt>true</tt> if this map contains no key-value mappings + */ + public boolean isEmpty() { + final Segment<K,V>[] segments = this.segments; + /* + * We keep track of per-segment modCounts to avoid ABA + * problems in which an element in one segment was added and + * in another removed during traversal, in which case the + * table was never actually empty at any point. Note the + * similar use of modCounts in the size() and containsValue() + * methods, which are the only other methods also susceptible + * to ABA problems. + */ + int[] mc = new int[segments.length]; + int mcsum = 0; + for (int i = 0; i < segments.length; ++i) { + if (segments[i].count != 0) + return false; + else + mcsum += mc[i] = segments[i].modCount; + } + // If mcsum happens to be zero, then we know we got a snapshot + // before any modifications at all were made. This is + // probably common enough to bother tracking. + if (mcsum != 0) { + for (int i = 0; i < segments.length; ++i) { + if (segments[i].count != 0 || + mc[i] != segments[i].modCount) + return false; + } + } + return true; + } + + /** + * Returns the number of key-value mappings in this map. If the + * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns + * <tt>Integer.MAX_VALUE</tt>. + * + * @return the number of key-value mappings in this map + */ + public int size() { + final Segment<K,V>[] segments = this.segments; + long sum = 0; + long check = 0; + int[] mc = new int[segments.length]; + // Try a few times to get accurate count. On failure due to + // continuous async changes in table, resort to locking. + for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) { + check = 0; + sum = 0; + int mcsum = 0; + for (int i = 0; i < segments.length; ++i) { + sum += segments[i].count; + mcsum += mc[i] = segments[i].modCount; + } + if (mcsum != 0) { + for (int i = 0; i < segments.length; ++i) { + check += segments[i].count; + if (mc[i] != segments[i].modCount) { + check = -1; // force retry + break; + } + } + } + if (check == sum) + break; + } + if (check != sum) { // Resort to locking all segments + sum = 0; + for (int i = 0; i < segments.length; ++i) + segments[i].lock(); + for (int i = 0; i < segments.length; ++i) + sum += segments[i].count; + for (int i = 0; i < segments.length; ++i) + segments[i].unlock(); + } + if (sum > Integer.MAX_VALUE) + return Integer.MAX_VALUE; + else + return (int)sum; + } + + /** + * Returns the value to which the specified key is mapped, + * or {@code null} if this map contains no mapping for the key. + * + * <p>More formally, if this map contains a mapping from a key + * {@code k} to a value {@code v} such that {@code key.equals(k)}, + * then this method returns {@code v}; otherwise it returns + * {@code null}. (There can be at most one such mapping.) + * + * @throws NullPointerException if the specified key is null + */ + public V get(Object key) { + int hash = hashOf(key); + return segmentFor(hash).get(key, hash); + } + + /** + * Tests if the specified object is a key in this table. + * + * @param key possible key + * @return <tt>true</tt> if and only if the specified object + * is a key in this table, as determined by the + * <tt>equals</tt> method; <tt>false</tt> otherwise. + * @throws NullPointerException if the specified key is null + */ + public boolean containsKey(Object key) { + int hash = hashOf(key); + return segmentFor(hash).containsKey(key, hash); + } + + /** + * Returns <tt>true</tt> if this map maps one or more keys to the + * specified value. Note: This method requires a full internal + * traversal of the hash table, and so is much slower than + * method <tt>containsKey</tt>. + * + * @param value value whose presence in this map is to be tested + * @return <tt>true</tt> if this map maps one or more keys to the + * specified value + * @throws NullPointerException if the specified value is null + */ + public boolean containsValue(Object value) { + if (value == null) + throw new NullPointerException(); + + // See explanation of modCount use above + + final Segment<K,V>[] segments = this.segments; + int[] mc = new int[segments.length]; + + // Try a few times without locking + for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) { + int sum = 0; + int mcsum = 0; + for (int i = 0; i < segments.length; ++i) { + int c = segments[i].count; + mcsum += mc[i] = segments[i].modCount; + if (segments[i].containsValue(value)) + return true; + } + boolean cleanSweep = true; + if (mcsum != 0) { + for (int i = 0; i < segments.length; ++i) { + int c = segments[i].count; + if (mc[i] != segments[i].modCount) { + cleanSweep = false; + break; + } + } + } + if (cleanSweep) + return false; + } + // Resort to locking all segments + for (int i = 0; i < segments.length; ++i) + segments[i].lock(); + boolean found = false; + try { + for (int i = 0; i < segments.length; ++i) { + if (segments[i].containsValue(value)) { + found = true; + break; + } + } + } finally { + for (int i = 0; i < segments.length; ++i) + segments[i].unlock(); + } + return found; + } + + /** + * Legacy method testing if some key maps into the specified value + * in this table. This method is identical in functionality to + * {@link #containsValue}, and exists solely to ensure + * full compatibility with class {@link java.util.Hashtable}, + * which supported this method prior to introduction of the + * Java Collections framework. + + * @param value a value to search for + * @return <tt>true</tt> if and only if some key maps to the + * <tt>value</tt> argument in this table as + * determined by the <tt>equals</tt> method; + * <tt>false</tt> otherwise + * @throws NullPointerException if the specified value is null + */ + public boolean contains(Object value) { + return containsValue(value); + } + + /** + * Maps the specified key to the specified value in this table. + * Neither the key nor the value can be null. + * + * <p> The value can be retrieved by calling the <tt>get</tt> method + * with a key that is equal to the original key. + * + * @param key key with which the specified value is to be associated + * @param value value to be associated with the specified key + * @return the previous value associated with <tt>key</tt>, or + * <tt>null</tt> if there was no mapping for <tt>key</tt> + * @throws NullPointerException if the specified key or value is null + */ + public V put(K key, V value) { + if (value == null) + throw new NullPointerException(); + int hash = hashOf(key); + return segmentFor(hash).put(key, hash, value, false); + } + + /** + * {@inheritDoc} + * + * @return the previous value associated with the specified key, + * or <tt>null</tt> if there was no mapping for the key + * @throws NullPointerException if the specified key or value is null + */ + public V putIfAbsent(K key, V value) { + if (value == null) + throw new NullPointerException(); + int hash = hashOf(key); + return segmentFor(hash).put(key, hash, value, true); + } + + /** + * Copies all of the mappings from the specified map to this one. + * These mappings replace any mappings that this map had for any of the + * keys currently in the specified map. + * + * @param m mappings to be stored in this map + */ + public void putAll(Map<? extends K, ? extends V> m) { + for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) + put(e.getKey(), e.getValue()); + } + + /** + * Removes the key (and its corresponding value) from this map. + * This method does nothing if the key is not in the map. + * + * @param key the key that needs to be removed + * @return the previous value associated with <tt>key</tt>, or + * <tt>null</tt> if there was no mapping for <tt>key</tt> + * @throws NullPointerException if the specified key is null + */ + public V remove(Object key) { + int hash = hashOf(key); + return segmentFor(hash).remove(key, hash, null, false); + } + + /** + * {@inheritDoc} + * + * @throws NullPointerException if the specified key is null + */ + public boolean remove(Object key, Object value) { + int hash = hashOf(key); + if (value == null) + return false; + return segmentFor(hash).remove(key, hash, value, false) != null; + } + + /** + * {@inheritDoc} + * + * @throws NullPointerException if any of the arguments are null + */ + public boolean replace(K key, V oldValue, V newValue) { + if (oldValue == null || newValue == null) + throw new NullPointerException(); + int hash = hashOf(key); + return segmentFor(hash).replace(key, hash, oldValue, newValue); + } + + /** + * {@inheritDoc} + * + * @return the previous value associated with the specified key, + * or <tt>null</tt> if there was no mapping for the key + * @throws NullPointerException if the specified key or value is null + */ + public V replace(K key, V value) { + if (value == null) + throw new NullPointerException(); + int hash = hashOf(key); + return segmentFor(hash).replace(key, hash, value); + } + + /** + * Removes all of the mappings from this map. + */ + public void clear() { + for (int i = 0; i < segments.length; ++i) + segments[i].clear(); + } + + /** + * Removes any stale entries whose keys have been finalized. Use of this + * method is normally not necessary since stale entries are automatically + * removed lazily, when blocking operations are required. However, there + * are some cases where this operation should be performed eagerly, such + * as cleaning up old references to a ClassLoader in a multi-classloader + * environment. + * + * Note: this method will acquire locks, one at a time, across all segments + * of this table, so if it is to be used, it should be used sparingly. + */ + public void purgeStaleEntries() { + for (int i = 0; i < segments.length; ++i) + segments[i].removeStale(); + } + + + /** + * Returns a {@link Set} view of the keys contained in this map. + * The set is backed by the map, so changes to the map are + * reflected in the set, and vice-versa. The set supports element + * removal, which removes the corresponding mapping from this map, + * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, + * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> + * operations. It does not support the <tt>add</tt> or + * <tt>addAll</tt> operations. + * + * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator + * that will never throw {@link 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. + */ + public Set<K> keySet() { + Set<K> ks = keySet; + return (ks != null) ? ks : (keySet = new KeySet()); + } + + /** + * Returns a {@link Collection} view of the values contained in this map. + * The collection is backed by the map, so changes to the map are + * reflected in the collection, and vice-versa. The collection + * supports element removal, which removes the corresponding + * mapping from this map, via the <tt>Iterator.remove</tt>, + * <tt>Collection.remove</tt>, <tt>removeAll</tt>, + * <tt>retainAll</tt>, and <tt>clear</tt> operations. It does not + * support the <tt>add</tt> or <tt>addAll</tt> operations. + * + * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator + * that will never throw {@link 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. + */ + public Collection<V> values() { + Collection<V> vs = values; + return (vs != null) ? vs : (values = new Values()); + } + + /** + * Returns a {@link Set} view of the mappings contained in this map. + * The set is backed by the map, so changes to the map are + * reflected in the set, and vice-versa. The set supports element + * removal, which removes the corresponding mapping from the map, + * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, + * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> + * operations. It does not support the <tt>add</tt> or + * <tt>addAll</tt> operations. + * + * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator + * that will never throw {@link 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. + */ + public Set<Map.Entry<K,V>> entrySet() { + Set<Map.Entry<K,V>> es = entrySet; + return (es != null) ? es : (entrySet = new EntrySet()); + } + + /** + * Returns an enumeration of the keys in this table. + * + * @return an enumeration of the keys in this table + * @see #keySet() + */ + public Enumeration<K> keys() { + return new KeyIterator(); + } + + /** + * Returns an enumeration of the values in this table. + * + * @return an enumeration of the values in this table + * @see #values() + */ + public Enumeration<V> elements() { + return new ValueIterator(); + } + + /* ---------------- Iterator Support -------------- */ + + abstract class HashIterator { + int nextSegmentIndex; + int nextTableIndex; + HashEntry<K,V>[] currentTable; + HashEntry<K, V> nextEntry; + HashEntry<K, V> lastReturned; + K currentKey; // Strong reference to weak key (prevents gc) + + HashIterator() { + nextSegmentIndex = segments.length - 1; + nextTableIndex = -1; + advance(); + } + + public boolean hasMoreElements() { return hasNext(); } + + final void advance() { + if (nextEntry != null && (nextEntry = nextEntry.next) != null) + return; + + while (nextTableIndex >= 0) { + if ( (nextEntry = currentTable[nextTableIndex--]) != null) + return; + } + + while (nextSegmentIndex >= 0) { + Segment<K,V> seg = segments[nextSegmentIndex--]; + if (seg.count != 0) { + currentTable = seg.table; + for (int j = currentTable.length - 1; j >= 0; --j) { + if ( (nextEntry = currentTable[j]) != null) { + nextTableIndex = j - 1; + return; + } + } + } + } + } + + public boolean hasNext() { + while (nextEntry != null) { + if (nextEntry.key() != null) + return true; + advance(); + } + + return false; + } + + HashEntry<K,V> nextEntry() { + do { + if (nextEntry == null) + throw new NoSuchElementException(); + + lastReturned = nextEntry; + currentKey = lastReturned.key(); + advance(); + } while (currentKey == null); // Skip GC'd keys + + return lastReturned; + } + + public void remove() { + if (lastReturned == null) + throw new IllegalStateException(); + ConcurrentReferenceHashMap.this.remove(currentKey); + lastReturned = null; + } + } + + final class KeyIterator + extends HashIterator + implements Iterator<K>, Enumeration<K> + { + public K next() { return super.nextEntry().key(); } + public K nextElement() { return super.nextEntry().key(); } + } + + final class ValueIterator + extends HashIterator + implements Iterator<V>, Enumeration<V> + { + public V next() { return super.nextEntry().value(); } + public V nextElement() { return super.nextEntry().value(); } + } + + /* + * This class is needed for JDK5 compatibility. + */ + static class SimpleEntry<K, V> implements Entry<K, V>, + java.io.Serializable { + private static final long serialVersionUID = -8499721149061103585L; + + private final K key; + private V value; + + public SimpleEntry(K key, V value) { + this.key = key; + this.value = value; + } + + public SimpleEntry(Entry<? extends K, ? extends V> entry) { + this.key = entry.getKey(); + this.value = entry.getValue(); + } + + public K getKey() { + return key; + } + + public V getValue() { + return value; + } + + public V setValue(V value) { + V oldValue = this.value; + this.value = value; + return oldValue; + } + + public boolean equals(Object o) { + if (!(o instanceof Map.Entry)) + return false; + @SuppressWarnings("unchecked") + Map.Entry e = (Map.Entry) o; + return eq(key, e.getKey()) && eq(value, e.getValue()); + } + + public int hashCode() { + return (key == null ? 0 : key.hashCode()) + ^ (value == null ? 0 : value.hashCode()); + } + + public String toString() { + return key + "=" + value; + } + + private static boolean eq(Object o1, Object o2) { + return o1 == null ? o2 == null : o1.equals(o2); + } + } + + + /** + * Custom Entry class used by EntryIterator.next(), that relays setValue + * changes to the underlying map. + */ + final class WriteThroughEntry extends SimpleEntry<K,V> + { + private static final long serialVersionUID = -7900634345345313646L; + + WriteThroughEntry(K k, V v) { + super(k,v); + } + + /** + * Set our entry's value and write through to the map. The + * value to return is somewhat arbitrary here. Since a + * WriteThroughEntry does not necessarily track asynchronous + * changes, the most recent "previous" value could be + * different from what we return (or could even have been + * removed in which case the put will re-establish). We do not + * and cannot guarantee more. + */ + public V setValue(V value) { + if (value == null) throw new NullPointerException(); + V v = super.setValue(value); + ConcurrentReferenceHashMap.this.put(getKey(), value); + return v; + } + } + + final class EntryIterator + extends HashIterator + implements Iterator<Entry<K,V>> + { + public Map.Entry<K,V> next() { + HashEntry<K,V> e = super.nextEntry(); + return new WriteThroughEntry(e.key(), e.value()); + } + } + + final class KeySet extends AbstractSet<K> { + public Iterator<K> iterator() { + return new KeyIterator(); + } + public int size() { + return ConcurrentReferenceHashMap.this.size(); + } + public boolean isEmpty() { + return ConcurrentReferenceHashMap.this.isEmpty(); + } + public boolean contains(Object o) { + return ConcurrentReferenceHashMap.this.containsKey(o); + } + public boolean remove(Object o) { + return ConcurrentReferenceHashMap.this.remove(o) != null; + } + public void clear() { + ConcurrentReferenceHashMap.this.clear(); + } + } + + final class Values extends AbstractCollection<V> { + public Iterator<V> iterator() { + return new ValueIterator(); + } + public int size() { + return ConcurrentReferenceHashMap.this.size(); + } + public boolean isEmpty() { + return ConcurrentReferenceHashMap.this.isEmpty(); + } + public boolean contains(Object o) { + return ConcurrentReferenceHashMap.this.containsValue(o); + } + public void clear() { + ConcurrentReferenceHashMap.this.clear(); + } + } + + final class EntrySet extends AbstractSet<Map.Entry<K,V>> { + public Iterator<Map.Entry<K,V>> iterator() { + return new EntryIterator(); + } + public boolean contains(Object o) { + if (!(o instanceof Map.Entry)) + return false; + Map.Entry<?,?> e = (Map.Entry<?,?>)o; + V v = ConcurrentReferenceHashMap.this.get(e.getKey()); + return v != null && v.equals(e.getValue()); + } + public boolean remove(Object o) { + if (!(o instanceof Map.Entry)) + return false; + Map.Entry<?,?> e = (Map.Entry<?,?>)o; + return ConcurrentReferenceHashMap.this.remove(e.getKey(), e.getValue()); + } + public int size() { + return ConcurrentReferenceHashMap.this.size(); + } + public boolean isEmpty() { + return ConcurrentReferenceHashMap.this.isEmpty(); + } + public void clear() { + ConcurrentReferenceHashMap.this.clear(); + } + } + + /* ---------------- Serialization Support -------------- */ + + /** + * Save the state of the <tt>ConcurrentReferenceHashMap</tt> instance to a + * stream (i.e., serialize it). + * @param s the stream + * @serialData + * the key (Object) and value (Object) + * for each key-value mapping, followed by a null pair. + * The key-value mappings are emitted in no particular order. + */ + private void writeObject(java.io.ObjectOutputStream s) throws IOException { + s.defaultWriteObject(); + + for (int k = 0; k < segments.length; ++k) { + Segment<K,V> seg = segments[k]; + seg.lock(); + try { + HashEntry<K,V>[] tab = seg.table; + for (int i = 0; i < tab.length; ++i) { + for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) { + K key = e.key(); + if (key == null) // Skip GC'd keys + continue; + + s.writeObject(key); + s.writeObject(e.value()); + } + } + } finally { + seg.unlock(); + } + } + s.writeObject(null); + s.writeObject(null); + } + + /** + * Reconstitute the <tt>ConcurrentReferenceHashMap</tt> instance from a + * stream (i.e., deserialize it). + * @param s the stream + */ + @SuppressWarnings("unchecked") + private void readObject(java.io.ObjectInputStream s) + throws IOException, ClassNotFoundException { + s.defaultReadObject(); + + // Initialize each segment to be minimally sized, and let grow. + for (int i = 0; i < segments.length; ++i) { + segments[i].setTable(new HashEntry[1]); + } + + // Read the keys and values, and put the mappings in the table + for (;;) { + K key = (K) s.readObject(); + V value = (V) s.readObject(); + if (key == null) + break; + put(key, value); + } + } +} Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/EndpointImpl.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/EndpointImpl.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/EndpointImpl.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,33 +1,35 @@ package org.jboss.remoting.core; +import java.io.Closeable; import java.io.IOException; -import java.io.Closeable; +import java.lang.ref.WeakReference; import java.net.URI; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.Executor; -import java.lang.ref.WeakReference; import org.jboss.remoting.Client; import org.jboss.remoting.ClientSource; +import org.jboss.remoting.CloseHandler; import org.jboss.remoting.Endpoint; +import org.jboss.remoting.EndpointPermission; +import org.jboss.remoting.LocalServiceConfiguration; +import org.jboss.remoting.RemoteServiceConfiguration; import org.jboss.remoting.RequestListener; import org.jboss.remoting.ServiceListener; +import org.jboss.remoting.ServiceURI; import org.jboss.remoting.SimpleCloseable; -import org.jboss.remoting.LocalServiceConfiguration; -import org.jboss.remoting.EndpointPermission; -import org.jboss.remoting.RemoteServiceConfiguration; -import org.jboss.remoting.ServiceURI; -import org.jboss.remoting.CloseHandler; -import org.jboss.remoting.core.util.OrderedExecutorFactory; -import org.jboss.remoting.core.util.CollectionUtil; +import org.jboss.remoting.Version; +import org.jboss.remoting.spi.AbstractHandleableCloseable; +import org.jboss.remoting.spi.AbstractSimpleCloseable; import org.jboss.remoting.spi.Handle; import org.jboss.remoting.spi.RequestHandler; import org.jboss.remoting.spi.RequestHandlerSource; -import org.jboss.remoting.spi.AbstractHandleableCloseable; -import org.jboss.remoting.spi.AbstractSimpleCloseable; -import org.jboss.remoting.Version; import org.jboss.xnio.FailedIoFuture; import org.jboss.xnio.FinishedIoFuture; import org.jboss.xnio.IoFuture; @@ -45,17 +47,23 @@ Logger.getLogger("org.jboss.remoting").info("JBoss Remoting version %s", Version.VERSION); } + static <K, V> Map<K, V> hashMap() { + return new HashMap<K, V>(); + } + + static <T> Set<T> hashSet() { + return new HashSet<T>(); + } + private static final Logger log = Logger.getLogger("org.jboss.remoting.endpoint"); private final String name; - private final OrderedExecutorFactory orderedExecutorFactory; + private final ConcurrentMap<Object, Object> endpointMap = new ConcurrentHashMap<Object, Object>(); - private final ConcurrentMap<Object, Object> endpointMap = CollectionUtil.concurrentMap(); - private final Object serviceLock = new Object(); - private final Map<Object, ServiceListenerRegistration> serviceListenerMap = CollectionUtil.hashMap(); - private final Set<ServiceRegistration> serviceRegistrations = CollectionUtil.hashSet(); + private final Map<Object, ServiceListenerRegistration> serviceListenerMap = hashMap(); + private final Set<ServiceRegistration> serviceRegistrations = hashSet(); private static final EndpointPermission CREATE_ENDPOINT_PERM = new EndpointPermission("createEndpoint"); private static final EndpointPermission CREATE_REQUEST_HANDLER_PERM = new EndpointPermission("createRequestHandler"); @@ -73,13 +81,12 @@ } this.executor = executor; this.name = name; - orderedExecutorFactory = new OrderedExecutorFactory(executor); } private final Executor executor; protected Executor getOrderedExecutor() { - return orderedExecutorFactory.getOrderedExecutor(); + return new OrderedExecutor(executor); } protected Executor getExecutor() { @@ -265,7 +272,7 @@ final String serviceType = ServiceURI.getServiceType(serviceUri); synchronized (serviceLock) { int bestMetric = Integer.MAX_VALUE; - List<ServiceRegistration> candidates = CollectionUtil.arrayList(); + List<ServiceRegistration> candidates = new ArrayList<ServiceRegistration>(); for (ServiceRegistration svc : serviceRegistrations) { if (svc.matches(serviceType, groupName, endpointName)) { final int metric = svc.getMetric(); Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/FutureReplyImpl.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/FutureReplyImpl.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/FutureReplyImpl.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -24,9 +24,9 @@ import java.io.IOException; import java.util.concurrent.Executor; +import org.jboss.remoting.ReplyException; import org.jboss.remoting.spi.RemoteRequestContext; import org.jboss.remoting.spi.ReplyHandler; -import org.jboss.remoting.ReplyException; import org.jboss.xnio.AbstractIoFuture; import org.jboss.xnio.IoFuture; Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/LocalRequestHandler.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/LocalRequestHandler.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/LocalRequestHandler.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -26,8 +26,8 @@ import java.util.concurrent.Executor; import java.util.concurrent.RejectedExecutionException; import org.jboss.remoting.RemoteExecutionException; +import org.jboss.remoting.RemoteRequestException; import org.jboss.remoting.RequestListener; -import org.jboss.remoting.RemoteRequestException; import org.jboss.remoting.spi.AbstractAutoCloseable; import org.jboss.remoting.spi.RemoteRequestContext; import org.jboss.remoting.spi.ReplyHandler; Copied: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/OrderedExecutor.java (from rev 4847, remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutor.java) =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/OrderedExecutor.java (rev 0) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/OrderedExecutor.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -0,0 +1,95 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, JBoss Inc., and individual contributors as indicated + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ + +package org.jboss.remoting.core; + +import java.util.LinkedList; +import java.util.concurrent.Executor; +import org.jboss.xnio.log.Logger; + +/** + * An executor that always runs all tasks in order, using a delegate executor to run the tasks. + * <p/> + * More specifically, any call B to the {@link #execute(Runnable)} method that happens-after another call A to the + * same method, will result in B's task running after A's. + */ +public final class OrderedExecutor implements Executor { + private static final Logger log = Logger.getLogger(OrderedExecutor.class); + + // @protectedby tasks + private final LinkedList<Runnable> tasks = new LinkedList<Runnable>(); + // @protectedby tasks + private boolean running; + private final Executor parent; + private final Runnable runner; + + /** + * Construct a new instance. + * + * @param parent the parent executor + */ + public OrderedExecutor(final Executor parent) { + this.parent = parent; + runner = new Runnable() { + public void run() { + for (;;) { + final Runnable task; + synchronized(tasks) { + task = tasks.poll(); + if (task == null) { + running = false; + return; + } + } + try { + task.run(); + } catch (Throwable t) { + log.error(t, "Runnable task %s failed", task); + } + } + } + }; + } + + /** + * Run a task. + * + * @param command the task to run. + */ + public void execute(Runnable command) { + synchronized(tasks) { + tasks.add(command); + if (! running) { + running = true; + boolean ok = false; + try { + parent.execute(runner); + ok = true; + } finally { + if (! ok) { + running = false; + } + } + } + } + } +} Copied: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/QueueExecutor.java (from rev 4847, remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/QueueExecutor.java) =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/QueueExecutor.java (rev 0) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/QueueExecutor.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -0,0 +1,101 @@ +package org.jboss.remoting.core; + +import java.util.LinkedList; +import java.util.Queue; +import org.jboss.xnio.CloseableExecutor; +import org.jboss.xnio.log.Logger; + +/** + * An executor designed to run all submitted tasks in the current thread. The queue is run continuously + * until the {@code close()} method is invoked. Jobs may be submitted to the queue from any thread. + * Only one thread should invoke the {@code runQueue()} method, which will run until the executor is + * shut down. + */ +public final class QueueExecutor implements CloseableExecutor { + private static final Logger log = org.jboss.xnio.log.Logger.getLogger(QueueExecutor.class); + + private final Queue<Runnable> queue = new LinkedList<Runnable>(); + + private State state = State.WAITING; + + private enum State { + RUNNING, + WAITING, + STOPPING, + DOWN, + } + + public void execute(Runnable command) { + synchronized(queue) { + switch (state) { + case WAITING: + state = State.RUNNING; + queue.notify(); + // fall thru + case STOPPING: + case RUNNING: + queue.add(command); + break; + default: + throw new IllegalStateException("Executor is no longer available"); + } + } + } + + public void runQueue() { + boolean intr = Thread.interrupted(); + try { + for (;;) { + final State newState; + synchronized(queue) { + while (state == State.WAITING) { + try { + queue.wait(); + } catch (InterruptedException e) { + intr = true; + } + } + if (state == State.DOWN) { + throw new IllegalStateException("DOWN"); + } + newState = state; + } + for (;;) { + final Runnable runnable; + synchronized(queue) { + runnable = queue.poll(); + if (runnable == null) { + break; + } + } + try { + runnable.run(); + } catch (Throwable t) { + log.trace(t, "Error occurred while processing run queue"); + } + } + if (newState == State.STOPPING) { + synchronized(queue) { + state = State.DOWN; + return; + } + } + } + } finally { + if (intr) { + Thread.currentThread().interrupt(); + } + } + } + + public void close() { + synchronized(queue) { + switch (state) { + case WAITING: + queue.notify(); + case RUNNING: + state = State.STOPPING; + } + } + } +} Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestContextImpl.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestContextImpl.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestContextImpl.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -25,9 +25,9 @@ import java.io.IOException; import java.util.HashSet; import java.util.Set; +import java.util.concurrent.Executor; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.Executor; import org.jboss.remoting.ClientContext; import org.jboss.remoting.IndeterminateOutcomeException; import org.jboss.remoting.RemoteExecutionException; Modified: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestListenerExecutor.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestListenerExecutor.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/RequestListenerExecutor.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -22,16 +22,17 @@ package org.jboss.remoting.core; +import java.util.Collections; +import java.util.HashSet; import java.util.Set; import java.util.concurrent.Executor; -import org.jboss.remoting.core.util.CollectionUtil; /** * */ public final class RequestListenerExecutor implements Executor { - private final Set<Task> tasks = CollectionUtil.synchronizedHashSet(); + private final Set<Task> tasks = Collections.synchronizedSet(new HashSet<Task>()); private final Executor executor; private final RequestContextImpl<?> requestContext; Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/AtomicMap.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/AtomicMap.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/AtomicMap.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,108 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Collection; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.ConcurrentMap; - -/** - * A delegating map implementation that accepts a standard {@code Map}, but conforms to the contract - * for {@code ConcurrentMap}. No synchronization is done on the delegate. - */ -public class AtomicMap<K, V> implements ConcurrentMap<K, V> { - private final Map<K, V> delegate; - - public AtomicMap(final Map<K, V> delegate) { - this.delegate = delegate; - } - - public int size() { - return delegate.size(); - } - - public boolean isEmpty() { - return delegate.isEmpty(); - } - - public boolean containsKey(final Object key) { - return delegate.containsKey(key); - } - - public boolean containsValue(final Object value) { - return delegate.containsValue(value); - } - - public V get(final Object key) { - return delegate.get(key); - } - - public V put(final K key, final V value) { - return delegate.put(key, value); - } - - public V remove(final Object key) { - return delegate.remove(key); - } - - public void putAll(final Map<? extends K, ? extends V> t) { - delegate.putAll(t); - } - - public void clear() { - delegate.clear(); - } - - public Set<K> keySet() { - return delegate.keySet(); - } - - public Collection<V> values() { - return delegate.values(); - } - - public Set<Entry<K, V>> entrySet() { - return delegate.entrySet(); - } - - public boolean equals(final Object o) { - return delegate.equals(o); - } - - public int hashCode() { - return delegate.hashCode(); - } - - public V putIfAbsent(final K key, final V value) { - if (delegate.containsKey(key)) { - return delegate.get(key); - } else { - return delegate.put(key, value); - } - } - - public boolean remove(final Object key, final Object value) { - if (delegate.containsKey(key) && (value == null && delegate.get(key) == null || delegate.get(key).equals(value))) { - delegate.remove(key); - return true; - } else { - return false; - } - } - - public boolean replace(final K key, final V oldValue, final V newValue) { - if (delegate.containsKey(key) && (oldValue == null ? delegate.get(key) == null : delegate.get(key).equals(oldValue))) { - delegate.put(key, newValue); - return true; - } else { - return false; - } - } - - public V replace(final K key, final V value) { - if (delegate.containsKey(key)) { - return delegate.put(key, value); - } else { - return null; - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/CollectionUtil.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/CollectionUtil.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/CollectionUtil.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,722 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.lang.reflect.Array; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.EnumMap; -import java.util.Enumeration; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; -import java.util.ListIterator; -import java.util.Map; -import java.util.NoSuchElementException; -import java.util.Queue; -import java.util.Set; -import java.util.WeakHashMap; -import java.util.concurrent.ArrayBlockingQueue; -import java.util.concurrent.BlockingQueue; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import static org.jboss.remoting.core.util.ConcurrentReferenceHashMap.ReferenceType.STRONG; -import static org.jboss.remoting.core.util.ConcurrentReferenceHashMap.ReferenceType.WEAK; - -/** - * A set of helpful utility functions for collections. - */ -public final class CollectionUtil { - private CollectionUtil() { - } - - /** - * Create an enum map for the given key type. - * - * @param keyType the key type - * @return the new map - */ - public static <K extends Enum<K>, V> EnumMap<K, V> enumMap(Class<K> keyType) { - return new EnumMap<K, V>(keyType); - } - - /** - * Create a concurrent map instance. - * - * @return a new concurrent map - */ - public static <K, V> ConcurrentMap<K, V> concurrentMap() { - return new ConcurrentHashMap<K, V>(); - } - - /** - * Create a concurrent map with weak keys. - * - * @return a new concurrent map with weak keys - */ - public static <K, V> ConcurrentMap<K, V> concurrentWeakMap() { - return new ConcurrentReferenceHashMap<K, V>(16, WEAK, STRONG); - } - - /** - * Create a concurrent map with weak values. - * - * @return a new concurrent map with weak values - */ - public static <K, V> ConcurrentMap<K, V> concurrentWeakValueMap() { - return new ConcurrentReferenceHashMap<K, V>(16, STRONG, WEAK); - } - - /** - * Create a synchronized map that obeys the contract for {@code ConcurrentMap}. - * - * @param original the map to be wrapped - * @return a synchronized map - */ - public static <K, V> ConcurrentMap<K, V> synchronizedMap(Map<K, V> original) { - return new SynchronizedMap<K, V>(original); - } - - /** - * Create a synchronized hash map that obeys the contract for {@code ConcurrentMap}. - * - * @return a synchronized hash map - */ - public static <K, V> ConcurrentMap<K, V> synchronizedHashMap() { - return synchronizedMap(CollectionUtil.<K, V>hashMap()); - } - - /** - * Create an array-backed list. - * - * @return an array-backed list - */ - public static <T> List<T> arrayList() { - return new ArrayList<T>(); - } - - /** - * Create a linked list. - * - * @return a linked list - */ - public static <T> LinkedList<T> linkedList() { - return new LinkedList<T>(); - } - - /** - * Create a synchronized array-backed list. - * - * @return a synchronized array-backed list - */ - public static <T> List<T> synchronizedArrayList() { - return Collections.synchronizedList(CollectionUtil.<T>arrayList()); - } - - /** - * Create an array-backed list whose contents are a copy of the given list. - * - * @param orig the original list - * @return an array backed list - */ - public static <T> List<T> arrayList(List<T> orig) { - return new ArrayList<T>(orig); - } - - /** - * Create a synchronized wrapper for the given set. - * - * @param nested the nested set - * @return a synchronized version of the nested set - */ - public static <T> Set<T> synchronizedSet(Set<T> nested) { - return new SynchronizedSet<T>(nested); - } - - /** - * Create a synchronized hash set. - * - * @return a synchronized hash set - */ - public static <T> Set<T> synchronizedHashSet() { - return synchronizedSet(CollectionUtil.<T>hashSet()); - } - - /** - * Create a synchronized weak hash set. - * - * @return a synchronized weak hash set - */ - public static <T> Set<T> synchronizedWeakHashSet() { - return synchronizedSet(CollectionUtil.<T>weakHashSet()); - } - - /** - * Create a synchronized version of the nested queue that obeys the contract for {@code BlockingQueue}. - * - * @param nested the nested queue - * @return the blocking queue - */ - public static <T> BlockingQueue<T> synchronizedQueue(Queue<T> nested) { - return new SynchronizedQueue<T>(nested); - } - - /** - * Create a weak hash set. - * - * @return a weak hash set - */ - public static <T> Set<T> weakHashSet() { - return new WeakHashSet<T>(); - } - - /** - * Create a fixed-capacity blocking queue. - * - * @param size the fixed size - * @return a fixed-capacity blocking queue - */ - public static <T> BlockingQueue<T> blockingQueue(int size) { - return new ArrayBlockingQueue<T>(size); - } - - /** - * Create a hash set. - * - * @return a hash set - */ - public static <T> Set<T> hashSet() { - return new HashSet<T>(); - } - - /** - * Create a hash map with weak keys. See {@link java.util.WeakHashMap}. - * - * @return a hash map with weak keys - */ - public static <K, V> Map<K, V> weakHashMap() { - return new WeakHashMap<K, V>(); - } - - /** - * Create a synchronized hash map with weak keys, which obeys the {@code ConcurrentMap} contract. - * - * @return a synchronized weak hash map - */ - public static <K, V> ConcurrentMap<K, V> synchronizedWeakHashMap() { - return CollectionUtil.<K,V>synchronizedMap(CollectionUtil.<K,V>weakHashMap()); - } - - /** - * Create an unmodifiable list view of an array. - * - * @param entries the array - * @return an unmodifiable list - */ - public static <T> List<T> unmodifiableList(final T... entries) { - return Collections.unmodifiableList(Arrays.asList(entries)); - } - - /** - * Create a hash map. - * - * @return a hash map - */ - public static <K, V> Map<K, V> hashMap() { - return new HashMap<K, V>(); - } - - /** - * Create an immutable map entry. - * - * @param key the key - * @param value the value - * @return the entry - */ - public static <K, V> Map.Entry<K, V> entry(final K key, final V value) { - return new Map.Entry<K, V>() { - public K getKey() { - return key; - } - - public V getValue() { - return value; - } - - public V setValue(final V value) { - throw new UnsupportedOperationException("setValue"); - } - }; - } - - /** - * Create a prepopulated hash map. The map will be sized for the number of elements given. - * - * @param entries the map entries - * @return the prepopulated hash map - */ - public static <K, V> Map<K, V> hashMap(Map.Entry<K, V>... entries) { - final Map<K, V> map = new HashMap<K, V>(entries.length); - for (Map.Entry<K,V> e : entries) { - map.put(e.getKey(), e.getValue()); - } - return map; - } - - /** - * Create an unmodifiable prepopulated hash map. - * - * @param entries the map entries - * @return the unmodifiable prepopulated hash map - */ - public static <K, V> Map<K, V> unmodifiableHashMap(Map.Entry<K, V>... entries) { - return Collections.unmodifiableMap(hashMap(entries)); - } - - /** - * Create an {@code Iterable} view of another {@code Iterable} that exposes no other methods. - * - * @param original the wrapped instance - * @return a new {@code Iterable} - */ - public static <T> Iterable<T> protectedIterable(Iterable<T> original) { - return new DelegateIterable<T>(original); - } - - /** - * Create an {@code Iterable} view of an {@code Enumeration}. The view can be used only once. - * - * @param enumeration the enumeration - * @return the {@code Iterable} view - */ - public static <T> Iterable<T> loop(final Enumeration<T> enumeration) { - return new Iterable<T>() { - public Iterator<T> iterator() { - return CollectionUtil.iterator(enumeration); - } - }; - } - - /** - * Create an {@code Iterable} view of an {@code Iterator}. The view can be used only once. - * - * @param iterator the iterator - * @return the {@code Iterable} view - */ - public static <T> Iterable<T> loop(final Iterator<T> iterator) { - return new Iterable<T>() { - public Iterator<T> iterator() { - return iterator; - } - }; - } - - /** - * Create an {@code Iterator} view of an {@code Enumeration}. - * - * @param enumeration the enumeration - * @return the {@code Iterator} view - */ - public static <T> Iterator<T> iterator(final Enumeration<T> enumeration) { - return new Iterator<T>() { - public boolean hasNext() { - return enumeration.hasMoreElements(); - } - - public T next() { - return enumeration.nextElement(); - } - - public void remove() { - throw new UnsupportedOperationException("remove()"); - } - }; - } - - /** - * Create an iterable view of a string split by a given delimiter. - * - * @param delimiter the delimiter - * @param subject the original string - * @return the iterable split view - */ - public static Iterable<String> split(final String delimiter, final String subject) { - return new Iterable<String>() { - public Iterator<String> iterator() { - return new Iterator<String>(){ - private int position = 0; - - public boolean hasNext() { - return position != -1; - } - - public String next() { - if (position == -1) { - throw new NoSuchElementException("next() past end of iterator"); - } - final int nextDelim = subject.indexOf(delimiter, position); - try { - if (nextDelim == -1) { - return subject.substring(position); - } else { - return subject.substring(position, nextDelim); - } - } finally { - position = nextDelim == -1 ? -1 : nextDelim + 1; - } - } - - public void remove() { - throw new UnsupportedOperationException("remove() not supported"); - } - }; - } - }; - } - - /** - * Join a series of character sequences using a delimiter. - * - * @param delimiter the delimiter - * @param strings the strings - * @return a joined string - */ - public static String join(final CharSequence delimiter, final Iterable<? extends CharSequence> strings) { - StringBuilder builder = new StringBuilder(); - Iterator<? extends CharSequence> it = strings.iterator(); - while (it.hasNext()) { - CharSequence s = it.next(); - builder.append(s); - if (it.hasNext()) { - builder.append(delimiter); - } - } - return builder.toString(); - } - - @SuppressWarnings({ "unchecked" }) - private static <T> T[] unroll(final Iterator<? extends T> iterator, final Class<T> type, final int c) { - if (iterator.hasNext()) { - final T t = iterator.next(); - T[] array = unroll(iterator, type, c + 1); - array[c] = t; - return array; - } else { - return (T[]) Array.newInstance(type, c); - } - } - - @SuppressWarnings({ "unchecked" }) - private static <T> T[] unrollReversed(final Iterator<? extends T> iterator, final Class<T> type, final int c) { - if (iterator.hasNext()) { - final T t = iterator.next(); - T[] array = unroll(iterator, type, c + 1); - array[array.length - c - 1] = t; - return array; - } else { - return (T[]) Array.newInstance(type, c); - } - } - - /** - * Convert an iterator to an array. The iterator should be relatively short to avoid blowing out the - * stack. - * - * @param iterator the iterator - * @param type the array element type - * @return the array - */ - public static <T> T[] toArray(final Iterator<? extends T> iterator, final Class<T> type) { - return unroll(iterator, type, 0); - } - - /** - * Convert an iterator to an array in reverse order. The iterator should be relatively short to avoid blowing out the - * stack. - * - * @param iterator the iterator - * @param type the array element type - * @return the array - */ - public static <T> T[] toArrayReversed(final Iterator<? extends T> iterator, final Class<T> type) { - return unrollReversed(iterator, type, 0); - } - - /** - * Determine if one array begins with another. If {@code prefix} is empty (has a length of zero), then this method - * always returns {@code true}. If {@code prefix} is longer than {@code theArray}, this method returns {@code false}. - * Otherwise {@code true} is returned if the first {@code N} elements of {@code theArray} are equal to the corresponding - * element in {@code prefix}, where {@code N} is equal to the length of {@code prefix}. "Equal" in this context means - * that either both elements being compared are {@code null}, or they are equal by way of {@code Object.equals()}. - * - * @param theArray the array to test - * @param prefix the prefix to test against - * @return {@code true} if {@code theArray} starts with {@code prefix} - */ - public static boolean arrayStartsWith(Object[] theArray, Object[] prefix) { - if (prefix.length > theArray.length) { - return false; - } - for (int i = 0; i < prefix.length; i ++) { - final Object prefixObject = prefix[i]; - final Object testObject = theArray[i]; - if (testObject == null) { - if (prefixObject != null) { - return false; - } - } else { - if (prefixObject == null || ! prefixObject.equals(testObject)) { - return false; - } - } - } - return true; - } - - /** - * Get the empty iterable. - * - * @return the empty iterable - */ - @SuppressWarnings ({"unchecked"}) - public static <T> Iterable<T> emptyIterable() { - return (Iterable<T>) EMPTY_ITERABLE; - } - - private static final Iterable<?> EMPTY_ITERABLE = new EmptyIterable(); - - private static class EmptyIterable implements Iterable<Object> { - public Iterator<Object> iterator() { - return emptyIterator(); - } - } - - /** - * Get the empty iterator. - * - * @return the empty iterator - */ - @SuppressWarnings ({"unchecked"}) - public static <T> Iterator<T> emptyIterator() { - return (Iterator<T>) EMPTY_ITERATOR; - } - - private static final Iterator<?> EMPTY_ITERATOR = new EmptyIterator(); - - private static final class EmptyIterator implements Iterator<Object> { - - public boolean hasNext() { - return false; - } - - public Object next() { - throw new NoSuchElementException("next() past end of iterator"); - } - - public void remove() { - throw new IllegalStateException("next() has not yet been called"); - } - - } - - /** - * Get a reversed view of a list iterator. - * - * @param original the original iterator - * @return the reversed view - */ - public static <T> ListIterator<T> reverse(ListIterator<T> original) { - if (original instanceof ReverseListIterator) { - return ((ReverseListIterator<T>)original).original; - } else { - return new ReverseListIterator<T>(original); - } - } - - /** - * Get an iterable reversed view of a list. - * - * @param list the list - * @return the reversed view - */ - public static <T> Iterable<T> reverse(final List<T> list) { - return new Iterable<T>() { - public Iterator<T> iterator() { - return reverse(list.listIterator(list.size())); - } - }; - } - - private static final class ReverseListIterator<T> implements ListIterator<T> { - - private final ListIterator<T> original; - - private ReverseListIterator(final ListIterator<T> original) { - this.original = original; - } - - public boolean hasNext() { - return original.hasPrevious(); - } - - public T next() { - return original.previous(); - } - - public boolean hasPrevious() { - return original.hasNext(); - } - - public T previous() { - return original.next(); - } - - public int nextIndex() { - return original.previousIndex(); - } - - public int previousIndex() { - return original.nextIndex(); - } - - public void remove() { - original.remove(); - } - - public void set(final T o) { - original.set(o); - } - - public void add(final T o) { - original.add(o); - original.previous(); - } - } - - /** - * Combine two {@code Iterator}s into one. - * - * @param first the first {@code Iterator} - * @param second the second {@code Iterator} - * @return a combined {@code Iterator} - */ - public static <T> Iterator<T> combine(final Iterator<? extends T> first, final Iterator<? extends T> second) { - if (first == null) { - throw new NullPointerException("first is null"); - } - if (second == null) { - throw new NullPointerException("second is null"); - } - return new Iterator<T>() { - private Iterator<? extends T> current = first; - private Iterator<? extends T> next = second; - - public boolean hasNext() { - if (current == null) { - return false; - } - if (! current.hasNext()) { - current = next; - next = null; - } - return current != null && current.hasNext(); - } - - public T next() { - if (current == null) { - throw new NoSuchElementException("next() past end of iterator"); - } - return current.next(); - } - - public void remove() { - current.remove(); - } - }; - } - - /** - * Combine three {@code Iterator}s into one. - * - * @param first the first {@code Iterator} - * @param second the second {@code Iterator} - * @param third the third {@code Iterator} - * @return a new combined {@code Iterator} - */ - public static <T> Iterator<T> combine(final Iterator<? extends T> first, final Iterator<? extends T> second, final Iterator<? extends T> third) { - return combine(combine(first, second), third); - } - - /** - * Combine four {@code Iterator}s into one. - * - * @param first the first {@code Iterator} - * @param second the second {@code Iterator} - * @param third the third {@code Iterator} - * @param fourth the fourth {@code Iterator} - * @return a new combined {@code Iterator} - */ - public static <T> Iterator<T> combine(final Iterator<? extends T> first, final Iterator<? extends T> second, final Iterator<? extends T> third, final Iterator<? extends T> fourth) { - return combine(combine(first, second), combine(third, fourth)); - } - - /** - * Combine two {@code Iterable}s into one. - * - * @param first the first {@code Iterable} - * @param second the second {@code Iterable} - * @return a new combined {@code Iterable} - */ - public static <T> Iterable<T> combine(final Iterable<? extends T> first, final Iterable<? extends T> second) { - if (first == null) { - throw new NullPointerException("first is null"); - } - if (second == null) { - throw new NullPointerException("second is null"); - } - return new Iterable<T>() { - public Iterator<T> iterator() { - return combine(first.iterator(), second.iterator()); - } - }; - } - - /** - * Combine three {@code Iterable}s into one. - * - * @param first the first {@code Iterable} - * @param second the second {@code Iterable} - * @param third the third {@code Iterable} - * @return a new combined {@code Iterable} - */ - public static <T> Iterable<T> combine(final Iterable<? extends T> first, final Iterable<? extends T> second, final Iterable<? extends T> third) { - return combine(combine(first, second), third); - } - - /** - * Combine four {@code Iterable}s into one. - * - * @param first the first {@code Iterable} - * @param second the second {@code Iterable} - * @param third the third {@code Iterable} - * @param fourth the fourth {@code Iterable} - * @return a new combined {@code Iterable} - */ - public static <T> Iterable<T> combine(final Iterable<? extends T> first, final Iterable<? extends T> second, final Iterable<? extends T> third, final Iterable<? extends T> fourth) { - return combine(combine(first, second), combine(third, fourth)); - } - - private static final class DelegateIterable<T> implements Iterable<T> { - - private final Iterable<T> delegate; - - public DelegateIterable(final Iterable<T> delegate) { - this.delegate = delegate; - } - - public Iterator<T> iterator() { - return delegate.iterator(); - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/ConcurrentReferenceHashMap.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/ConcurrentReferenceHashMap.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/ConcurrentReferenceHashMap.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,1709 +0,0 @@ -/* - * Written by Doug Lea with assistance from members of JCP JSR-166 - * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain - */ - -package org.jboss.remoting.core.util; -import java.io.IOException; -import java.io.Serializable; -import java.lang.ref.Reference; -import java.lang.ref.ReferenceQueue; -import java.lang.ref.SoftReference; -import java.lang.ref.WeakReference; -import java.util.AbstractCollection; -import java.util.AbstractMap; -import java.util.AbstractSet; -import java.util.Collection; -import java.util.ConcurrentModificationException; -import java.util.EnumSet; -import java.util.Enumeration; -import java.util.HashMap; -import java.util.Hashtable; -import java.util.IdentityHashMap; -import java.util.Iterator; -import java.util.Map; -import java.util.NoSuchElementException; -import java.util.Set; -import java.util.concurrent.locks.ReentrantLock; - -/** - * An advanced hash table supporting configurable garbage collection semantics - * of keys and values, optional referential-equality, full concurrency of - * retrievals, and adjustable expected concurrency for updates. - * - * This table is designed around specific advanced use-cases. If there is any - * doubt whether this table is for you, you most likely should be using - * {@link java.util.concurrent.ConcurrentHashMap} instead. - * - * This table supports strong, weak, and soft keys and values. By default keys - * are weak, and values are strong. Such a configuration offers similar behavior - * to {@link java.util.WeakHashMap}, entries of this table are periodically - * removed once their corresponding keys are no longer referenced outside of - * this table. In other words, this table will not prevent a key from being - * discarded by the garbage collector. Once a key has been discarded by the - * collector, the corresponding entry is no longer visible to this table; - * however, the entry may occupy space until a future table operation decides to - * reclaim it. For this reason, summary functions such as <tt>size</tt> and - * <tt>isEmpty</tt> might return a value greater than the observed number of - * entries. In order to support a high level of concurrency, stale entries are - * only reclaimed during blocking (usually mutating) operations. - * - * Enabling soft keys allows entries in this table to remain until their space - * is absolutely needed by the garbage collector. This is unlike weak keys which - * can be reclaimed as soon as they are no longer referenced by a normal strong - * reference. The primary use case for soft keys is a cache, which ideally - * occupies memory that is not in use for as long as possible. - * - * By default, values are held using a normal strong reference. This provides - * the commonly desired guarantee that a value will always have at least the - * same life-span as it's key. For this reason, care should be taken to ensure - * that a value never refers, either directly or indirectly, to its key, thereby - * preventing reclamation. If this is unavoidable, then it is recommended to use - * the same reference type in use for the key. However, it should be noted that - * non-strong values may disappear before their corresponding key. - * - * While this table does allow the use of both strong keys and values, it is - * recommended to use {@link java.util.concurrent.ConcurrentHashMap} for such a - * configuration, since it is optimized for that case. - * - * Just like {@link java.util.concurrent.ConcurrentHashMap}, this class obeys - * the same functional specification as {@link java.util.Hashtable}, and - * includes versions of methods corresponding to each method of - * <tt>Hashtable</tt>. However, even though all operations are thread-safe, - * retrieval operations do <em>not</em> entail locking, and there is - * <em>not</em> any support for locking the entire table in a way that - * prevents all access. This class is fully interoperable with - * <tt>Hashtable</tt> in programs that rely on its thread safety but not on - * its synchronization details. - * - * <p> - * Retrieval operations (including <tt>get</tt>) generally do not block, so - * may overlap with update operations (including <tt>put</tt> and - * <tt>remove</tt>). Retrievals reflect the results of the most recently - * <em>completed</em> update operations holding upon their onset. For - * aggregate operations such as <tt>putAll</tt> and <tt>clear</tt>, - * concurrent retrievals may reflect insertion or removal of only some entries. - * Similarly, Iterators and Enumerations return elements reflecting the state of - * the hash table at some point at or since the creation of the - * iterator/enumeration. They do <em>not</em> throw - * {@link ConcurrentModificationException}. However, iterators are designed to - * be used by only one thread at a time. - * - * <p> - * The allowed concurrency among update operations is guided by the optional - * <tt>concurrencyLevel</tt> constructor argument (default <tt>16</tt>), - * which is used as a hint for internal sizing. The table is internally - * partitioned to try to permit the indicated number of concurrent updates - * without contention. Because placement in hash tables is essentially random, - * the actual concurrency will vary. Ideally, you should choose a value to - * accommodate as many threads as will ever concurrently modify the table. Using - * a significantly higher value than you need can waste space and time, and a - * significantly lower value can lead to thread contention. But overestimates - * and underestimates within an order of magnitude do not usually have much - * noticeable impact. A value of one is appropriate when it is known that only - * one thread will modify and all others will only read. Also, resizing this or - * any other kind of hash table is a relatively slow operation, so, when - * possible, it is a good idea to provide estimates of expected table sizes in - * constructors. - * - * <p> - * This class and its views and iterators implement all of the <em>optional</em> - * methods of the {@link Map} and {@link Iterator} interfaces. - * - * <p> - * Like {@link Hashtable} but unlike {@link HashMap}, this class does - * <em>not</em> allow <tt>null</tt> to be used as a key or value. - * - * <p> - * This class is a member of the <a href="{@docRoot}/../technotes/guides/collections/index.html"> - * Java Collections Framework</a>. - * - * @author Doug Lea - * @author Jason T. Greene - * @param <K> the type of keys maintained by this map - * @param <V> the type of mapped values - */ -public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V> - implements java.util.concurrent.ConcurrentMap<K, V>, Serializable { - private static final long serialVersionUID = 7249069246763182397L; - - /* - * The basic strategy is to subdivide the table among Segments, - * each of which itself is a concurrently readable hash table. - */ - - /** - * An option specifying which Java reference type should be used to refer - * to a key and/or value. - */ - public static enum ReferenceType { - /** Indicates a normal Java strong reference should be used */ - STRONG, - /** Indicates a {@link WeakReference} should be used */ - WEAK, - /** Indicates a {@link SoftReference} should be used */ - SOFT - }; - - - public static enum Option { - /** Indicates that referential-equality (== instead of .equals()) should - * be used when locating keys. This offers similar behavior to {@link IdentityHashMap} */ - IDENTITY_COMPARISONS - }; - - /* ---------------- Constants -------------- */ - - static final ReferenceType DEFAULT_KEY_TYPE = ReferenceType.WEAK; - - static final ReferenceType DEFAULT_VALUE_TYPE = ReferenceType.STRONG; - - - /** - * The default initial capacity for this table, - * used when not otherwise specified in a constructor. - */ - static final int DEFAULT_INITIAL_CAPACITY = 16; - - /** - * The default load factor for this table, used when not - * otherwise specified in a constructor. - */ - static final float DEFAULT_LOAD_FACTOR = 0.75f; - - /** - * The default concurrency level for this table, used when not - * otherwise specified in a constructor. - */ - static final int DEFAULT_CONCURRENCY_LEVEL = 16; - - /** - * The maximum capacity, used if a higher value is implicitly - * specified by either of the constructors with arguments. MUST - * be a power of two <= 1<<30 to ensure that entries are indexable - * using ints. - */ - static final int MAXIMUM_CAPACITY = 1 << 30; - - /** - * The maximum number of segments to allow; used to bound - * constructor arguments. - */ - static final int MAX_SEGMENTS = 1 << 16; // slightly conservative - - /** - * Number of unsynchronized retries in size and containsValue - * methods before resorting to locking. This is used to avoid - * unbounded retries if tables undergo continuous modification - * which would make it impossible to obtain an accurate result. - */ - static final int RETRIES_BEFORE_LOCK = 2; - - /* ---------------- Fields -------------- */ - - /** - * Mask value for indexing into segments. The upper bits of a - * key's hash code are used to choose the segment. - */ - final int segmentMask; - - /** - * Shift value for indexing within segments. - */ - final int segmentShift; - - /** - * The segments, each of which is a specialized hash table - */ - final Segment<K,V>[] segments; - - boolean identityComparisons; - - transient Set<K> keySet; - transient Set<Map.Entry<K,V>> entrySet; - transient Collection<V> values; - - /* ---------------- Small Utilities -------------- */ - - /** - * Applies a supplemental hash function to a given hashCode, which - * defends against poor quality hash functions. This is critical - * because ConcurrentReferenceHashMap uses power-of-two length hash tables, - * that otherwise encounter collisions for hashCodes that do not - * differ in lower or upper bits. - */ - private static int hash(int h) { - // Spread bits to regularize both segment and index locations, - // using variant of single-word Wang/Jenkins hash. - h += (h << 15) ^ 0xffffcd7d; - h ^= (h >>> 10); - h += (h << 3); - h ^= (h >>> 6); - h += (h << 2) + (h << 14); - return h ^ (h >>> 16); - } - - /** - * Returns the segment that should be used for key with given hash - * @param hash the hash code for the key - * @return the segment - */ - final Segment<K,V> segmentFor(int hash) { - return segments[(hash >>> segmentShift) & segmentMask]; - } - - private int hashOf(Object key) { - return hash(identityComparisons ? - System.identityHashCode(key) : key.hashCode()); - } - - /* ---------------- Inner Classes -------------- */ - - static interface KeyReference { - int keyHash(); - Object keyRef(); - } - - /** - * A weak-key reference which stores the key hash needed for reclamation. - */ - static final class WeakKeyReference<K> extends WeakReference<K> implements KeyReference { - final int hash; - WeakKeyReference(K key, int hash, ReferenceQueue<Object> refQueue) { - super(key, refQueue); - this.hash = hash; - } - public final int keyHash() { - return hash; - } - - public final Object keyRef() { - return this; - } - } - - /** - * A soft-key reference which stores the key hash needed for reclamation. - */ - static final class SoftKeyReference<K> extends SoftReference<K> implements KeyReference { - final int hash; - SoftKeyReference(K key, int hash, ReferenceQueue<Object> refQueue) { - super(key, refQueue); - this.hash = hash; - } - public final int keyHash() { - return hash; - } - - public final Object keyRef() { - return this; - } - } - - static final class WeakValueReference<V> extends WeakReference<V> implements KeyReference { - final Object keyRef; - final int hash; - WeakValueReference(V value, Object keyRef, int hash, ReferenceQueue<Object> refQueue) { - super(value, refQueue); - this.keyRef = keyRef; - this.hash = hash; - } - - public final int keyHash() { - return hash; - } - - public final Object keyRef() { - return keyRef; - } - } - - static final class SoftValueReference<V> extends SoftReference<V> implements KeyReference { - final Object keyRef; - final int hash; - SoftValueReference(V value, Object keyRef, int hash, ReferenceQueue<Object> refQueue) { - super(value, refQueue); - this.keyRef = keyRef; - this.hash = hash; - } - public final int keyHash() { - return hash; - } - - public final Object keyRef() { - return keyRef; - } - } - - /** - * ConcurrentReferenceHashMap list entry. Note that this is never exported - * out as a user-visible Map.Entry. - * - * Because the value field is volatile, not final, it is legal wrt - * the Java Memory Model for an unsynchronized reader to see null - * instead of initial value when read via a data race. Although a - * reordering leading to this is not likely to ever actually - * occur, the Segment.readValueUnderLock method is used as a - * backup in case a null (pre-initialized) value is ever seen in - * an unsynchronized access method. - */ - static final class HashEntry<K,V> { - final Object keyRef; - final int hash; - volatile Object valueRef; - final HashEntry<K,V> next; - - HashEntry(K key, int hash, HashEntry<K,V> next, V value, - ReferenceType keyType, ReferenceType valueType, - ReferenceQueue<Object> refQueue) { - this.hash = hash; - this.next = next; - this.keyRef = newKeyReference(key, keyType, refQueue); - this.valueRef = newValueReference(value, valueType, refQueue); - } - - final Object newKeyReference(K key, ReferenceType keyType, - ReferenceQueue<Object> refQueue) { - if (keyType == ReferenceType.WEAK) - return new WeakKeyReference<K>(key, hash, refQueue); - if (keyType == ReferenceType.SOFT) - return new SoftKeyReference<K>(key, hash, refQueue); - - return key; - } - - final Object newValueReference(V value, ReferenceType valueType, - ReferenceQueue<Object> refQueue) { - if (valueType == ReferenceType.WEAK) - return new WeakValueReference<V>(value, keyRef, hash, refQueue); - if (valueType == ReferenceType.SOFT) - return new SoftValueReference<V>(value, keyRef, hash, refQueue); - - return value; - } - - @SuppressWarnings("unchecked") - final K key() { - if (keyRef instanceof Reference) - return ((Reference<K>)keyRef).get(); - - return (K) keyRef; - } - - final V value() { - return dereferenceValue(valueRef); - } - - @SuppressWarnings("unchecked") - final V dereferenceValue(Object value) { - if (value instanceof Reference) - return ((Reference<V>)value).get(); - - return (V) value; - } - - final void setValue(V value, ReferenceType valueType, ReferenceQueue<Object> refQueue) { - this.valueRef = newValueReference(value, valueType, refQueue); - } - - @SuppressWarnings("unchecked") - static final <K,V> HashEntry<K,V>[] newArray(int i) { - return new HashEntry[i]; - } - } - - /** - * Segments are specialized versions of hash tables. This - * subclasses from ReentrantLock opportunistically, just to - * simplify some locking and avoid separate construction. - */ - static final class Segment<K,V> extends ReentrantLock implements Serializable { - /* - * Segments maintain a table of entry lists that are ALWAYS - * kept in a consistent state, so can be read without locking. - * Next fields of nodes are immutable (final). All list - * additions are performed at the front of each bin. This - * makes it easy to check changes, and also fast to traverse. - * When nodes would otherwise be changed, new nodes are - * created to replace them. This works well for hash tables - * since the bin lists tend to be short. (The average length - * is less than two for the default load factor threshold.) - * - * Read operations can thus proceed without locking, but rely - * on selected uses of volatiles to ensure that completed - * write operations performed by other threads are - * noticed. For most purposes, the "count" field, tracking the - * number of elements, serves as that volatile variable - * ensuring visibility. This is convenient because this field - * needs to be read in many read operations anyway: - * - * - All (unsynchronized) read operations must first read the - * "count" field, and should not look at table entries if - * it is 0. - * - * - All (synchronized) write operations should write to - * the "count" field after structurally changing any bin. - * The operations must not take any action that could even - * momentarily cause a concurrent read operation to see - * inconsistent data. This is made easier by the nature of - * the read operations in Map. For example, no operation - * can reveal that the table has grown but the threshold - * has not yet been updated, so there are no atomicity - * requirements for this with respect to reads. - * - * As a guide, all critical volatile reads and writes to the - * count field are marked in code comments. - */ - - private static final long serialVersionUID = 2249069246763182397L; - - /** - * The number of elements in this segment's region. - */ - transient volatile int count; - - /** - * Number of updates that alter the size of the table. This is - * used during bulk-read methods to make sure they see a - * consistent snapshot: If modCounts change during a traversal - * of segments computing size or checking containsValue, then - * we might have an inconsistent view of state so (usually) - * must retry. - */ - transient int modCount; - - /** - * The table is rehashed when its size exceeds this threshold. - * (The value of this field is always <tt>(int)(capacity * - * loadFactor)</tt>.) - */ - transient int threshold; - - /** - * The per-segment table. - */ - transient volatile HashEntry<K,V>[] table; - - /** - * The load factor for the hash table. Even though this value - * is same for all segments, it is replicated to avoid needing - * links to outer object. - * @serial - */ - final float loadFactor; - - /** - * The collected weak-key reference queue for this segment. - * This should be (re)initialized whenever table is assigned, - */ - transient volatile ReferenceQueue<Object> refQueue; - - final ReferenceType keyType; - - final ReferenceType valueType; - - final boolean identityComparisons; - - Segment(int initialCapacity, float lf, ReferenceType keyType, - ReferenceType valueType, boolean identityComparisons) { - loadFactor = lf; - this.keyType = keyType; - this.valueType = valueType; - this.identityComparisons = identityComparisons; - setTable(HashEntry.<K,V>newArray(initialCapacity)); - } - - @SuppressWarnings("unchecked") - static final <K,V> Segment<K,V>[] newArray(int i) { - return new Segment[i]; - } - - private boolean keyEq(Object src, Object dest) { - return identityComparisons ? src == dest : src.equals(dest); - } - - /** - * Sets table to new HashEntry array. - * Call only while holding lock or in constructor. - */ - void setTable(HashEntry<K,V>[] newTable) { - threshold = (int)(newTable.length * loadFactor); - table = newTable; - refQueue = new ReferenceQueue<Object>(); - } - - /** - * Returns properly casted first entry of bin for given hash. - */ - HashEntry<K,V> getFirst(int hash) { - HashEntry<K,V>[] tab = table; - return tab[hash & (tab.length - 1)]; - } - - HashEntry<K,V> newHashEntry(K key, int hash, HashEntry<K, V> next, V value) { - return new HashEntry<K,V>(key, hash, next, value, keyType, valueType, refQueue); - } - - /** - * Reads value field of an entry under lock. Called if value - * field ever appears to be null. This is possible only if a - * compiler happens to reorder a HashEntry initialization with - * its table assignment, which is legal under memory model - * but is not known to ever occur. - */ - V readValueUnderLock(HashEntry<K,V> e) { - lock(); - try { - removeStale(); - return e.value(); - } finally { - unlock(); - } - } - - /* Specialized implementations of map methods */ - - V get(Object key, int hash) { - if (count != 0) { // read-volatile - HashEntry<K,V> e = getFirst(hash); - while (e != null) { - if (e.hash == hash && keyEq(key, e.key())) { - Object opaque = e.valueRef; - if (opaque != null) - return e.dereferenceValue(opaque); - - return readValueUnderLock(e); // recheck - } - e = e.next; - } - } - return null; - } - - boolean containsKey(Object key, int hash) { - if (count != 0) { // read-volatile - HashEntry<K,V> e = getFirst(hash); - while (e != null) { - if (e.hash == hash && keyEq(key, e.key())) - return true; - e = e.next; - } - } - return false; - } - - boolean containsValue(Object value) { - if (count != 0) { // read-volatile - HashEntry<K,V>[] tab = table; - int len = tab.length; - for (int i = 0 ; i < len; i++) { - for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) { - Object opaque = e.valueRef; - V v; - - if (opaque == null) - v = readValueUnderLock(e); // recheck - else - v = e.dereferenceValue(opaque); - - if (value.equals(v)) - return true; - } - } - } - return false; - } - - boolean replace(K key, int hash, V oldValue, V newValue) { - lock(); - try { - removeStale(); - HashEntry<K,V> e = getFirst(hash); - while (e != null && (e.hash != hash || !keyEq(key, e.key()))) - e = e.next; - - boolean replaced = false; - if (e != null && oldValue.equals(e.value())) { - replaced = true; - e.setValue(newValue, valueType, refQueue); - } - return replaced; - } finally { - unlock(); - } - } - - V replace(K key, int hash, V newValue) { - lock(); - try { - removeStale(); - HashEntry<K,V> e = getFirst(hash); - while (e != null && (e.hash != hash || !keyEq(key, e.key()))) - e = e.next; - - V oldValue = null; - if (e != null) { - oldValue = e.value(); - e.setValue(newValue, valueType, refQueue); - } - return oldValue; - } finally { - unlock(); - } - } - - - V put(K key, int hash, V value, boolean onlyIfAbsent) { - lock(); - try { - removeStale(); - int c = count; - if (c++ > threshold) {// ensure capacity - int reduced = rehash(); - if (reduced > 0) // adjust from possible weak cleanups - count = (c -= reduced) - 1; // write-volatile - } - - HashEntry<K,V>[] tab = table; - int index = hash & (tab.length - 1); - HashEntry<K,V> first = tab[index]; - HashEntry<K,V> e = first; - while (e != null && (e.hash != hash || !keyEq(key, e.key()))) - e = e.next; - - V oldValue; - if (e != null) { - oldValue = e.value(); - if (!onlyIfAbsent) - e.setValue(value, valueType, refQueue); - } - else { - oldValue = null; - ++modCount; - tab[index] = newHashEntry(key, hash, first, value); - count = c; // write-volatile - } - return oldValue; - } finally { - unlock(); - } - } - - int rehash() { - HashEntry<K,V>[] oldTable = table; - int oldCapacity = oldTable.length; - if (oldCapacity >= MAXIMUM_CAPACITY) - return 0; - - /* - * Reclassify nodes in each list to new Map. Because we are - * using power-of-two expansion, the elements from each bin - * must either stay at same index, or move with a power of two - * offset. We eliminate unnecessary node creation by catching - * cases where old nodes can be reused because their next - * fields won't change. Statistically, at the default - * threshold, only about one-sixth of them need cloning when - * a table doubles. The nodes they replace will be garbage - * collectable as soon as they are no longer referenced by any - * reader thread that may be in the midst of traversing table - * right now. - */ - - HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1); - threshold = (int)(newTable.length * loadFactor); - int sizeMask = newTable.length - 1; - int reduce = 0; - for (int i = 0; i < oldCapacity ; i++) { - // We need to guarantee that any existing reads of old Map can - // proceed. So we cannot yet null out each bin. - HashEntry<K,V> e = oldTable[i]; - - if (e != null) { - HashEntry<K,V> next = e.next; - int idx = e.hash & sizeMask; - - // Single node on list - if (next == null) - newTable[idx] = e; - - else { - // Reuse trailing consecutive sequence at same slot - HashEntry<K,V> lastRun = e; - int lastIdx = idx; - for (HashEntry<K,V> last = next; - last != null; - last = last.next) { - int k = last.hash & sizeMask; - if (k != lastIdx) { - lastIdx = k; - lastRun = last; - } - } - newTable[lastIdx] = lastRun; - // Clone all remaining nodes - for (HashEntry<K,V> p = e; p != lastRun; p = p.next) { - // Skip GC'd weak refs - K key = p.key(); - if (key == null) { - reduce++; - continue; - } - int k = p.hash & sizeMask; - HashEntry<K,V> n = newTable[k]; - newTable[k] = newHashEntry(key, p.hash, n, p.value()); - } - } - } - } - table = newTable; - return reduce; - } - - /** - * Remove; match on key only if value null, else match both. - */ - V remove(Object key, int hash, Object value, boolean refRemove) { - lock(); - try { - if (!refRemove) - removeStale(); - int c = count - 1; - HashEntry<K,V>[] tab = table; - int index = hash & (tab.length - 1); - HashEntry<K,V> first = tab[index]; - HashEntry<K,V> e = first; - // a ref remove operation compares the Reference instance - while (e != null && key != e.keyRef - && (refRemove || hash != e.hash || !keyEq(key, e.key()))) - e = e.next; - - V oldValue = null; - if (e != null) { - V v = e.value(); - if (value == null || value.equals(v)) { - oldValue = v; - // All entries following removed node can stay - // in list, but all preceding ones need to be - // cloned. - ++modCount; - HashEntry<K,V> newFirst = e.next; - for (HashEntry<K,V> p = first; p != e; p = p.next) { - K pKey = p.key(); - if (pKey == null) { // Skip GC'd keys - c--; - continue; - } - - newFirst = newHashEntry(pKey, p.hash, newFirst, p.value()); - } - tab[index] = newFirst; - count = c; // write-volatile - } - } - return oldValue; - } finally { - unlock(); - } - } - - final void removeStale() { - KeyReference ref; - while ((ref = (KeyReference) refQueue.poll()) != null) { - remove(ref.keyRef(), ref.keyHash(), null, true); - } - } - - void clear() { - if (count != 0) { - lock(); - try { - HashEntry<K,V>[] tab = table; - for (int i = 0; i < tab.length ; i++) - tab[i] = null; - ++modCount; - // replace the reference queue to avoid unnecessary stale cleanups - refQueue = new ReferenceQueue<Object>(); - count = 0; // write-volatile - } finally { - unlock(); - } - } - } - } - - - - /* ---------------- Public operations -------------- */ - - /** - * Creates a new, empty map with the specified initial - * capacity, reference types, load factor and concurrency level. - * - * Behavioral changing options such as {@link Option#IDENTITY_COMPARISONS} - * can also be specified. - * - * @param initialCapacity the initial capacity. The implementation - * performs internal sizing to accommodate this many elements. - * @param loadFactor the load factor threshold, used to control resizing. - * Resizing may be performed when the average number of elements per - * bin exceeds this threshold. - * @param concurrencyLevel the estimated number of concurrently - * updating threads. The implementation performs internal sizing - * to try to accommodate this many threads. - * @param keyType the reference type to use for keys - * @param valueType the reference type to use for values - * @param options the behavioral options - * @throws IllegalArgumentException if the initial capacity is - * negative or the load factor or concurrencyLevel are - * nonpositive. - */ - public ConcurrentReferenceHashMap(int initialCapacity, - float loadFactor, int concurrencyLevel, - ReferenceType keyType, ReferenceType valueType, - EnumSet<Option> options) { - if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) - throw new IllegalArgumentException(); - - if (concurrencyLevel > MAX_SEGMENTS) - concurrencyLevel = MAX_SEGMENTS; - - // Find power-of-two sizes best matching arguments - int sshift = 0; - int ssize = 1; - while (ssize < concurrencyLevel) { - ++sshift; - ssize <<= 1; - } - segmentShift = 32 - sshift; - segmentMask = ssize - 1; - this.segments = Segment.newArray(ssize); - - if (initialCapacity > MAXIMUM_CAPACITY) - initialCapacity = MAXIMUM_CAPACITY; - int c = initialCapacity / ssize; - if (c * ssize < initialCapacity) - ++c; - int cap = 1; - while (cap < c) - cap <<= 1; - - identityComparisons = options != null && options.contains(Option.IDENTITY_COMPARISONS); - - for (int i = 0; i < this.segments.length; ++i) - this.segments[i] = new Segment<K,V>(cap, loadFactor, - keyType, valueType, identityComparisons); - } - - /** - * Creates a new, empty map with the specified initial - * capacity, load factor and concurrency level. - * - * @param initialCapacity the initial capacity. The implementation - * performs internal sizing to accommodate this many elements. - * @param loadFactor the load factor threshold, used to control resizing. - * Resizing may be performed when the average number of elements per - * bin exceeds this threshold. - * @param concurrencyLevel the estimated number of concurrently - * updating threads. The implementation performs internal sizing - * to try to accommodate this many threads. - * @throws IllegalArgumentException if the initial capacity is - * negative or the load factor or concurrencyLevel are - * nonpositive. - */ - public ConcurrentReferenceHashMap(int initialCapacity, - float loadFactor, int concurrencyLevel) { - this(initialCapacity, loadFactor, concurrencyLevel, - DEFAULT_KEY_TYPE, DEFAULT_VALUE_TYPE, null); - } - - /** - * Creates a new, empty map with the specified initial capacity - * and load factor and with the default reference types (weak keys, - * strong values), and concurrencyLevel (16). - * - * @param initialCapacity The implementation performs internal - * sizing to accommodate this many elements. - * @param loadFactor the load factor threshold, used to control resizing. - * Resizing may be performed when the average number of elements per - * bin exceeds this threshold. - * @throws IllegalArgumentException if the initial capacity of - * elements is negative or the load factor is nonpositive - * - * @since 1.6 - */ - public ConcurrentReferenceHashMap(int initialCapacity, float loadFactor) { - this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL); - } - - - /** - * Creates a new, empty map with the specified initial capacity, - * reference types and with default load factor (0.75) and concurrencyLevel (16). - * - * @param initialCapacity the initial capacity. The implementation - * performs internal sizing to accommodate this many elements. - * @param keyType the reference type to use for keys - * @param valueType the reference type to use for values - * @throws IllegalArgumentException if the initial capacity of - * elements is negative. - */ - public ConcurrentReferenceHashMap(int initialCapacity, - ReferenceType keyType, ReferenceType valueType) { - this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL, - keyType, valueType, null); - } - - /** - * Creates a new, empty map with the specified initial capacity, - * and with default reference types (weak keys, strong values), - * load factor (0.75) and concurrencyLevel (16). - * - * @param initialCapacity the initial capacity. The implementation - * performs internal sizing to accommodate this many elements. - * @throws IllegalArgumentException if the initial capacity of - * elements is negative. - */ - public ConcurrentReferenceHashMap(int initialCapacity) { - this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); - } - - /** - * Creates a new, empty map with a default initial capacity (16), - * reference types (weak keys, strong values), default - * load factor (0.75) and concurrencyLevel (16). - */ - public ConcurrentReferenceHashMap() { - this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); - } - - /** - * Creates a new map with the same mappings as the given map. - * The map is created with a capacity of 1.5 times the number - * of mappings in the given map or 16 (whichever is greater), - * and a default load factor (0.75) and concurrencyLevel (16). - * - * @param m the map - */ - public ConcurrentReferenceHashMap(Map<? extends K, ? extends V> m) { - this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, - DEFAULT_INITIAL_CAPACITY), - DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); - putAll(m); - } - - /** - * Returns <tt>true</tt> if this map contains no key-value mappings. - * - * @return <tt>true</tt> if this map contains no key-value mappings - */ - public boolean isEmpty() { - final Segment<K,V>[] segments = this.segments; - /* - * We keep track of per-segment modCounts to avoid ABA - * problems in which an element in one segment was added and - * in another removed during traversal, in which case the - * table was never actually empty at any point. Note the - * similar use of modCounts in the size() and containsValue() - * methods, which are the only other methods also susceptible - * to ABA problems. - */ - int[] mc = new int[segments.length]; - int mcsum = 0; - for (int i = 0; i < segments.length; ++i) { - if (segments[i].count != 0) - return false; - else - mcsum += mc[i] = segments[i].modCount; - } - // If mcsum happens to be zero, then we know we got a snapshot - // before any modifications at all were made. This is - // probably common enough to bother tracking. - if (mcsum != 0) { - for (int i = 0; i < segments.length; ++i) { - if (segments[i].count != 0 || - mc[i] != segments[i].modCount) - return false; - } - } - return true; - } - - /** - * Returns the number of key-value mappings in this map. If the - * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns - * <tt>Integer.MAX_VALUE</tt>. - * - * @return the number of key-value mappings in this map - */ - public int size() { - final Segment<K,V>[] segments = this.segments; - long sum = 0; - long check = 0; - int[] mc = new int[segments.length]; - // Try a few times to get accurate count. On failure due to - // continuous async changes in table, resort to locking. - for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) { - check = 0; - sum = 0; - int mcsum = 0; - for (int i = 0; i < segments.length; ++i) { - sum += segments[i].count; - mcsum += mc[i] = segments[i].modCount; - } - if (mcsum != 0) { - for (int i = 0; i < segments.length; ++i) { - check += segments[i].count; - if (mc[i] != segments[i].modCount) { - check = -1; // force retry - break; - } - } - } - if (check == sum) - break; - } - if (check != sum) { // Resort to locking all segments - sum = 0; - for (int i = 0; i < segments.length; ++i) - segments[i].lock(); - for (int i = 0; i < segments.length; ++i) - sum += segments[i].count; - for (int i = 0; i < segments.length; ++i) - segments[i].unlock(); - } - if (sum > Integer.MAX_VALUE) - return Integer.MAX_VALUE; - else - return (int)sum; - } - - /** - * Returns the value to which the specified key is mapped, - * or {@code null} if this map contains no mapping for the key. - * - * <p>More formally, if this map contains a mapping from a key - * {@code k} to a value {@code v} such that {@code key.equals(k)}, - * then this method returns {@code v}; otherwise it returns - * {@code null}. (There can be at most one such mapping.) - * - * @throws NullPointerException if the specified key is null - */ - public V get(Object key) { - int hash = hashOf(key); - return segmentFor(hash).get(key, hash); - } - - /** - * Tests if the specified object is a key in this table. - * - * @param key possible key - * @return <tt>true</tt> if and only if the specified object - * is a key in this table, as determined by the - * <tt>equals</tt> method; <tt>false</tt> otherwise. - * @throws NullPointerException if the specified key is null - */ - public boolean containsKey(Object key) { - int hash = hashOf(key); - return segmentFor(hash).containsKey(key, hash); - } - - /** - * Returns <tt>true</tt> if this map maps one or more keys to the - * specified value. Note: This method requires a full internal - * traversal of the hash table, and so is much slower than - * method <tt>containsKey</tt>. - * - * @param value value whose presence in this map is to be tested - * @return <tt>true</tt> if this map maps one or more keys to the - * specified value - * @throws NullPointerException if the specified value is null - */ - public boolean containsValue(Object value) { - if (value == null) - throw new NullPointerException(); - - // See explanation of modCount use above - - final Segment<K,V>[] segments = this.segments; - int[] mc = new int[segments.length]; - - // Try a few times without locking - for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) { - int sum = 0; - int mcsum = 0; - for (int i = 0; i < segments.length; ++i) { - int c = segments[i].count; - mcsum += mc[i] = segments[i].modCount; - if (segments[i].containsValue(value)) - return true; - } - boolean cleanSweep = true; - if (mcsum != 0) { - for (int i = 0; i < segments.length; ++i) { - int c = segments[i].count; - if (mc[i] != segments[i].modCount) { - cleanSweep = false; - break; - } - } - } - if (cleanSweep) - return false; - } - // Resort to locking all segments - for (int i = 0; i < segments.length; ++i) - segments[i].lock(); - boolean found = false; - try { - for (int i = 0; i < segments.length; ++i) { - if (segments[i].containsValue(value)) { - found = true; - break; - } - } - } finally { - for (int i = 0; i < segments.length; ++i) - segments[i].unlock(); - } - return found; - } - - /** - * Legacy method testing if some key maps into the specified value - * in this table. This method is identical in functionality to - * {@link #containsValue}, and exists solely to ensure - * full compatibility with class {@link java.util.Hashtable}, - * which supported this method prior to introduction of the - * Java Collections framework. - - * @param value a value to search for - * @return <tt>true</tt> if and only if some key maps to the - * <tt>value</tt> argument in this table as - * determined by the <tt>equals</tt> method; - * <tt>false</tt> otherwise - * @throws NullPointerException if the specified value is null - */ - public boolean contains(Object value) { - return containsValue(value); - } - - /** - * Maps the specified key to the specified value in this table. - * Neither the key nor the value can be null. - * - * <p> The value can be retrieved by calling the <tt>get</tt> method - * with a key that is equal to the original key. - * - * @param key key with which the specified value is to be associated - * @param value value to be associated with the specified key - * @return the previous value associated with <tt>key</tt>, or - * <tt>null</tt> if there was no mapping for <tt>key</tt> - * @throws NullPointerException if the specified key or value is null - */ - public V put(K key, V value) { - if (value == null) - throw new NullPointerException(); - int hash = hashOf(key); - return segmentFor(hash).put(key, hash, value, false); - } - - /** - * {@inheritDoc} - * - * @return the previous value associated with the specified key, - * or <tt>null</tt> if there was no mapping for the key - * @throws NullPointerException if the specified key or value is null - */ - public V putIfAbsent(K key, V value) { - if (value == null) - throw new NullPointerException(); - int hash = hashOf(key); - return segmentFor(hash).put(key, hash, value, true); - } - - /** - * Copies all of the mappings from the specified map to this one. - * These mappings replace any mappings that this map had for any of the - * keys currently in the specified map. - * - * @param m mappings to be stored in this map - */ - public void putAll(Map<? extends K, ? extends V> m) { - for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) - put(e.getKey(), e.getValue()); - } - - /** - * Removes the key (and its corresponding value) from this map. - * This method does nothing if the key is not in the map. - * - * @param key the key that needs to be removed - * @return the previous value associated with <tt>key</tt>, or - * <tt>null</tt> if there was no mapping for <tt>key</tt> - * @throws NullPointerException if the specified key is null - */ - public V remove(Object key) { - int hash = hashOf(key); - return segmentFor(hash).remove(key, hash, null, false); - } - - /** - * {@inheritDoc} - * - * @throws NullPointerException if the specified key is null - */ - public boolean remove(Object key, Object value) { - int hash = hashOf(key); - if (value == null) - return false; - return segmentFor(hash).remove(key, hash, value, false) != null; - } - - /** - * {@inheritDoc} - * - * @throws NullPointerException if any of the arguments are null - */ - public boolean replace(K key, V oldValue, V newValue) { - if (oldValue == null || newValue == null) - throw new NullPointerException(); - int hash = hashOf(key); - return segmentFor(hash).replace(key, hash, oldValue, newValue); - } - - /** - * {@inheritDoc} - * - * @return the previous value associated with the specified key, - * or <tt>null</tt> if there was no mapping for the key - * @throws NullPointerException if the specified key or value is null - */ - public V replace(K key, V value) { - if (value == null) - throw new NullPointerException(); - int hash = hashOf(key); - return segmentFor(hash).replace(key, hash, value); - } - - /** - * Removes all of the mappings from this map. - */ - public void clear() { - for (int i = 0; i < segments.length; ++i) - segments[i].clear(); - } - - /** - * Removes any stale entries whose keys have been finalized. Use of this - * method is normally not necessary since stale entries are automatically - * removed lazily, when blocking operations are required. However, there - * are some cases where this operation should be performed eagerly, such - * as cleaning up old references to a ClassLoader in a multi-classloader - * environment. - * - * Note: this method will acquire locks, one at a time, across all segments - * of this table, so if it is to be used, it should be used sparingly. - */ - public void purgeStaleEntries() { - for (int i = 0; i < segments.length; ++i) - segments[i].removeStale(); - } - - - /** - * Returns a {@link Set} view of the keys contained in this map. - * The set is backed by the map, so changes to the map are - * reflected in the set, and vice-versa. The set supports element - * removal, which removes the corresponding mapping from this map, - * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, - * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> - * operations. It does not support the <tt>add</tt> or - * <tt>addAll</tt> operations. - * - * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator - * that will never throw {@link 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. - */ - public Set<K> keySet() { - Set<K> ks = keySet; - return (ks != null) ? ks : (keySet = new KeySet()); - } - - /** - * Returns a {@link Collection} view of the values contained in this map. - * The collection is backed by the map, so changes to the map are - * reflected in the collection, and vice-versa. The collection - * supports element removal, which removes the corresponding - * mapping from this map, via the <tt>Iterator.remove</tt>, - * <tt>Collection.remove</tt>, <tt>removeAll</tt>, - * <tt>retainAll</tt>, and <tt>clear</tt> operations. It does not - * support the <tt>add</tt> or <tt>addAll</tt> operations. - * - * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator - * that will never throw {@link 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. - */ - public Collection<V> values() { - Collection<V> vs = values; - return (vs != null) ? vs : (values = new Values()); - } - - /** - * Returns a {@link Set} view of the mappings contained in this map. - * The set is backed by the map, so changes to the map are - * reflected in the set, and vice-versa. The set supports element - * removal, which removes the corresponding mapping from the map, - * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, - * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> - * operations. It does not support the <tt>add</tt> or - * <tt>addAll</tt> operations. - * - * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator - * that will never throw {@link 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. - */ - public Set<Map.Entry<K,V>> entrySet() { - Set<Map.Entry<K,V>> es = entrySet; - return (es != null) ? es : (entrySet = new EntrySet()); - } - - /** - * Returns an enumeration of the keys in this table. - * - * @return an enumeration of the keys in this table - * @see #keySet() - */ - public Enumeration<K> keys() { - return new KeyIterator(); - } - - /** - * Returns an enumeration of the values in this table. - * - * @return an enumeration of the values in this table - * @see #values() - */ - public Enumeration<V> elements() { - return new ValueIterator(); - } - - /* ---------------- Iterator Support -------------- */ - - abstract class HashIterator { - int nextSegmentIndex; - int nextTableIndex; - HashEntry<K,V>[] currentTable; - HashEntry<K, V> nextEntry; - HashEntry<K, V> lastReturned; - K currentKey; // Strong reference to weak key (prevents gc) - - HashIterator() { - nextSegmentIndex = segments.length - 1; - nextTableIndex = -1; - advance(); - } - - public boolean hasMoreElements() { return hasNext(); } - - final void advance() { - if (nextEntry != null && (nextEntry = nextEntry.next) != null) - return; - - while (nextTableIndex >= 0) { - if ( (nextEntry = currentTable[nextTableIndex--]) != null) - return; - } - - while (nextSegmentIndex >= 0) { - Segment<K,V> seg = segments[nextSegmentIndex--]; - if (seg.count != 0) { - currentTable = seg.table; - for (int j = currentTable.length - 1; j >= 0; --j) { - if ( (nextEntry = currentTable[j]) != null) { - nextTableIndex = j - 1; - return; - } - } - } - } - } - - public boolean hasNext() { - while (nextEntry != null) { - if (nextEntry.key() != null) - return true; - advance(); - } - - return false; - } - - HashEntry<K,V> nextEntry() { - do { - if (nextEntry == null) - throw new NoSuchElementException(); - - lastReturned = nextEntry; - currentKey = lastReturned.key(); - advance(); - } while (currentKey == null); // Skip GC'd keys - - return lastReturned; - } - - public void remove() { - if (lastReturned == null) - throw new IllegalStateException(); - ConcurrentReferenceHashMap.this.remove(currentKey); - lastReturned = null; - } - } - - final class KeyIterator - extends HashIterator - implements Iterator<K>, Enumeration<K> - { - public K next() { return super.nextEntry().key(); } - public K nextElement() { return super.nextEntry().key(); } - } - - final class ValueIterator - extends HashIterator - implements Iterator<V>, Enumeration<V> - { - public V next() { return super.nextEntry().value(); } - public V nextElement() { return super.nextEntry().value(); } - } - - /* - * This class is needed for JDK5 compatibility. - */ - static class SimpleEntry<K, V> implements Entry<K, V>, - java.io.Serializable { - private static final long serialVersionUID = -8499721149061103585L; - - private final K key; - private V value; - - public SimpleEntry(K key, V value) { - this.key = key; - this.value = value; - } - - public SimpleEntry(Entry<? extends K, ? extends V> entry) { - this.key = entry.getKey(); - this.value = entry.getValue(); - } - - public K getKey() { - return key; - } - - public V getValue() { - return value; - } - - public V setValue(V value) { - V oldValue = this.value; - this.value = value; - return oldValue; - } - - public boolean equals(Object o) { - if (!(o instanceof Map.Entry)) - return false; - @SuppressWarnings("unchecked") - Map.Entry e = (Map.Entry) o; - return eq(key, e.getKey()) && eq(value, e.getValue()); - } - - public int hashCode() { - return (key == null ? 0 : key.hashCode()) - ^ (value == null ? 0 : value.hashCode()); - } - - public String toString() { - return key + "=" + value; - } - - private static boolean eq(Object o1, Object o2) { - return o1 == null ? o2 == null : o1.equals(o2); - } - } - - - /** - * Custom Entry class used by EntryIterator.next(), that relays setValue - * changes to the underlying map. - */ - final class WriteThroughEntry extends SimpleEntry<K,V> - { - private static final long serialVersionUID = -7900634345345313646L; - - WriteThroughEntry(K k, V v) { - super(k,v); - } - - /** - * Set our entry's value and write through to the map. The - * value to return is somewhat arbitrary here. Since a - * WriteThroughEntry does not necessarily track asynchronous - * changes, the most recent "previous" value could be - * different from what we return (or could even have been - * removed in which case the put will re-establish). We do not - * and cannot guarantee more. - */ - public V setValue(V value) { - if (value == null) throw new NullPointerException(); - V v = super.setValue(value); - ConcurrentReferenceHashMap.this.put(getKey(), value); - return v; - } - } - - final class EntryIterator - extends HashIterator - implements Iterator<Entry<K,V>> - { - public Map.Entry<K,V> next() { - HashEntry<K,V> e = super.nextEntry(); - return new WriteThroughEntry(e.key(), e.value()); - } - } - - final class KeySet extends AbstractSet<K> { - public Iterator<K> iterator() { - return new KeyIterator(); - } - public int size() { - return ConcurrentReferenceHashMap.this.size(); - } - public boolean isEmpty() { - return ConcurrentReferenceHashMap.this.isEmpty(); - } - public boolean contains(Object o) { - return ConcurrentReferenceHashMap.this.containsKey(o); - } - public boolean remove(Object o) { - return ConcurrentReferenceHashMap.this.remove(o) != null; - } - public void clear() { - ConcurrentReferenceHashMap.this.clear(); - } - } - - final class Values extends AbstractCollection<V> { - public Iterator<V> iterator() { - return new ValueIterator(); - } - public int size() { - return ConcurrentReferenceHashMap.this.size(); - } - public boolean isEmpty() { - return ConcurrentReferenceHashMap.this.isEmpty(); - } - public boolean contains(Object o) { - return ConcurrentReferenceHashMap.this.containsValue(o); - } - public void clear() { - ConcurrentReferenceHashMap.this.clear(); - } - } - - final class EntrySet extends AbstractSet<Map.Entry<K,V>> { - public Iterator<Map.Entry<K,V>> iterator() { - return new EntryIterator(); - } - public boolean contains(Object o) { - if (!(o instanceof Map.Entry)) - return false; - Map.Entry<?,?> e = (Map.Entry<?,?>)o; - V v = ConcurrentReferenceHashMap.this.get(e.getKey()); - return v != null && v.equals(e.getValue()); - } - public boolean remove(Object o) { - if (!(o instanceof Map.Entry)) - return false; - Map.Entry<?,?> e = (Map.Entry<?,?>)o; - return ConcurrentReferenceHashMap.this.remove(e.getKey(), e.getValue()); - } - public int size() { - return ConcurrentReferenceHashMap.this.size(); - } - public boolean isEmpty() { - return ConcurrentReferenceHashMap.this.isEmpty(); - } - public void clear() { - ConcurrentReferenceHashMap.this.clear(); - } - } - - /* ---------------- Serialization Support -------------- */ - - /** - * Save the state of the <tt>ConcurrentReferenceHashMap</tt> instance to a - * stream (i.e., serialize it). - * @param s the stream - * @serialData - * the key (Object) and value (Object) - * for each key-value mapping, followed by a null pair. - * The key-value mappings are emitted in no particular order. - */ - private void writeObject(java.io.ObjectOutputStream s) throws IOException { - s.defaultWriteObject(); - - for (int k = 0; k < segments.length; ++k) { - Segment<K,V> seg = segments[k]; - seg.lock(); - try { - HashEntry<K,V>[] tab = seg.table; - for (int i = 0; i < tab.length; ++i) { - for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) { - K key = e.key(); - if (key == null) // Skip GC'd keys - continue; - - s.writeObject(key); - s.writeObject(e.value()); - } - } - } finally { - seg.unlock(); - } - } - s.writeObject(null); - s.writeObject(null); - } - - /** - * Reconstitute the <tt>ConcurrentReferenceHashMap</tt> instance from a - * stream (i.e., deserialize it). - * @param s the stream - */ - @SuppressWarnings("unchecked") - private void readObject(java.io.ObjectInputStream s) - throws IOException, ClassNotFoundException { - s.defaultReadObject(); - - // Initialize each segment to be minimally sized, and let grow. - for (int i = 0; i < segments.length; ++i) { - segments[i].setTable(new HashEntry[1]); - } - - // Read the keys and values, and put the mappings in the table - for (;;) { - K key = (K) s.readObject(); - V value = (V) s.readObject(); - if (key == null) - break; - put(key, value); - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/DecodingBuilder.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/DecodingBuilder.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/DecodingBuilder.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,100 +0,0 @@ -/* - * JBoss, Home of Professional Open Source - * Copyright 2008, JBoss Inc., and individual contributors as indicated - * by the @authors tag. See the copyright.txt in the distribution for a - * full listing of individual contributors. - * - * This is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation; either version 2.1 of - * the License, or (at your option) any later version. - * - * This software 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this software; if not, write to the Free - * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - * 02110-1301 USA, or see the FSF site: http://www.fsf.org. - */ - -package org.jboss.remoting.core.util; - -import java.nio.ByteBuffer; -import java.nio.CharBuffer; -import java.nio.charset.Charset; -import java.nio.charset.CharsetDecoder; -import java.nio.charset.CodingErrorAction; -import static org.jboss.xnio.Buffers.flip; - -/** - * - */ -public final class DecodingBuilder { - private final StringBuilder stringBuilder; - private final CharsetDecoder decoder; - private final CharBuffer holder; - - public DecodingBuilder() { - this(64); - } - - public DecodingBuilder(String charset) { - this(charset, 64); - } - - public DecodingBuilder(Charset charset) { - this(charset, 64); - } - - public DecodingBuilder(Charset charset, int bufsize) { - stringBuilder = new StringBuilder(); - decoder = charset.newDecoder(); - holder = CharBuffer.allocate(bufsize); - decoder.onMalformedInput(CodingErrorAction.REPLACE); - decoder.onUnmappableCharacter(CodingErrorAction.REPLACE); - decoder.replaceWith("?"); - } - - public DecodingBuilder(int bufsize) { - this(Charset.defaultCharset(), bufsize); - } - - public DecodingBuilder(String charset, int bufsize) { - this(Charset.forName(charset), bufsize); - } - - public DecodingBuilder append(ByteBuffer buffer) { - boolean oflow; - do { - oflow = decoder.decode(buffer, holder, false).isOverflow(); - stringBuilder.append(flip(holder)); - holder.clear(); - } while (oflow); - return this; - } - - public static final ByteBuffer EMPTY = ByteBuffer.allocate(0); - - public DecodingBuilder finish() { - boolean oflow; - do { - oflow = decoder.decode(EMPTY, holder, true).isOverflow(); - stringBuilder.append(flip(holder)); - holder.clear(); - } while (oflow); - return this; - } - - public String toString() { - boolean oflow; - do { - oflow = decoder.flush(holder).isOverflow(); - stringBuilder.append(flip(holder)); - holder.clear(); - } while (oflow); - return stringBuilder.toString(); - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/NamingThreadFactory.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/NamingThreadFactory.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/NamingThreadFactory.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,35 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.concurrent.ThreadFactory; - -/** - * A wrapper {@code ThreadFactory} that gives the threads a sensible name. - */ -public final class NamingThreadFactory implements ThreadFactory { - private final ThreadFactory delegate; - private final String namePattern; - - /** - * Create a new instance. The pattern is a format string such as one would provide to - * {@link String#format(String, Object[])}. The format string should contain one {@code %s} which will be replaced - * with the original thread name. - * - * @param delegate the thread factory to actually use to produce the thread - * @param namePattern the name pattern to apply - */ - public NamingThreadFactory(final ThreadFactory delegate, final String namePattern) { - this.delegate = delegate; - this.namePattern = namePattern; - } - - public Thread newThread(final Runnable r) { - final Thread thread = delegate.newThread(r); - final String originalName = thread.getName(); - try { - thread.setName(String.format(namePattern, originalName)); - } catch (SecurityException ex) { - // oh well, we tried - } - return thread; - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutor.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutor.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutor.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,95 +0,0 @@ -/* - * JBoss, Home of Professional Open Source - * Copyright 2008, JBoss Inc., and individual contributors as indicated - * by the @authors tag. See the copyright.txt in the distribution for a - * full listing of individual contributors. - * - * This is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation; either version 2.1 of - * the License, or (at your option) any later version. - * - * This software 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this software; if not, write to the Free - * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - * 02110-1301 USA, or see the FSF site: http://www.fsf.org. - */ - -package org.jboss.remoting.core.util; - -import java.util.LinkedList; -import java.util.concurrent.Executor; -import org.jboss.xnio.log.Logger; - -/** - * An executor that always runs all tasks in order, using a delegate executor to run the tasks. - * <p/> - * More specifically, any call B to the {@link #execute(Runnable)} method that happens-after another call A to the - * same method, will result in B's task running after A's. - */ -public final class OrderedExecutor implements Executor { - private static final Logger log = Logger.getLogger(OrderedExecutor.class); - - // @protectedby tasks - private final LinkedList<Runnable> tasks = new LinkedList<Runnable>(); - // @protectedby tasks - private boolean running; - private final Executor parent; - private final Runnable runner; - - /** - * Construct a new instance. - * - * @param parent the parent executor - */ - public OrderedExecutor(final Executor parent) { - this.parent = parent; - runner = new Runnable() { - public void run() { - for (;;) { - final Runnable task; - synchronized(tasks) { - task = tasks.poll(); - if (task == null) { - running = false; - return; - } - } - try { - task.run(); - } catch (Throwable t) { - log.error(t, "Runnable task %s failed", task); - } - } - } - }; - } - - /** - * Run a task. - * - * @param command the task to run. - */ - public void execute(Runnable command) { - synchronized(tasks) { - tasks.add(command); - if (! running) { - running = true; - boolean ok = false; - try { - parent.execute(runner); - ok = true; - } finally { - if (! ok) { - running = false; - } - } - } - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutorFactory.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutorFactory.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/OrderedExecutorFactory.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,28 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.concurrent.Executor; - -/** - * A factory for producing executors that run all tasks in order, which delegate to a single common executor instance. - */ -public final class OrderedExecutorFactory { - private final Executor parent; - - /** - * Construct a new instance delegating to the given parent executor. - * - * @param parent the parent executor - */ - public OrderedExecutorFactory(final Executor parent) { - this.parent = parent; - } - - /** - * Get an executor that always executes tasks in order. - * - * @return an ordered executor - */ - public Executor getOrderedExecutor() { - return new OrderedExecutor(parent); - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/QueueExecutor.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/QueueExecutor.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/QueueExecutor.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,101 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.LinkedList; -import java.util.Queue; -import org.jboss.xnio.log.Logger; -import org.jboss.xnio.CloseableExecutor; - -/** - * An executor designed to run all submitted tasks in the current thread. The queue is run continuously - * until the {@code shutdown()} method is invoked. Jobs may be submitted to the queue from any thread. - * Only one thread should invoke the {@code runQueue()} method, which will run until the executor is - * shut down. - */ -public final class QueueExecutor implements CloseableExecutor { - private static final Logger log = org.jboss.xnio.log.Logger.getLogger(QueueExecutor.class); - - private final Queue<Runnable> queue = new LinkedList<Runnable>(); - - private State state = State.WAITING; - - private enum State { - RUNNING, - WAITING, - STOPPING, - DOWN, - } - - public void execute(Runnable command) { - synchronized(queue) { - switch (state) { - case WAITING: - state = State.RUNNING; - queue.notify(); - // fall thru - case STOPPING: - case RUNNING: - queue.add(command); - break; - default: - throw new IllegalStateException("Executor is no longer available"); - } - } - } - - public void runQueue() { - boolean intr = Thread.interrupted(); - try { - for (;;) { - final State newState; - synchronized(queue) { - while (state == State.WAITING) { - try { - queue.wait(); - } catch (InterruptedException e) { - intr = true; - } - } - if (state == State.DOWN) { - throw new IllegalStateException("DOWN"); - } - newState = state; - } - for (;;) { - final Runnable runnable; - synchronized(queue) { - runnable = queue.poll(); - if (runnable == null) { - break; - } - } - try { - runnable.run(); - } catch (Throwable t) { - log.trace(t, "Error occurred while processing run queue"); - } - } - if (newState == State.STOPPING) { - synchronized(queue) { - state = State.DOWN; - return; - } - } - } - } finally { - if (intr) { - Thread.currentThread().interrupt(); - } - } - } - - public void close() { - synchronized(queue) { - switch (state) { - case WAITING: - queue.notify(); - case RUNNING: - state = State.STOPPING; - } - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedCollection.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedCollection.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedCollection.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,118 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Collection; -import java.util.Iterator; - -/** - * - */ -public class SynchronizedCollection<V> implements Collection<V> { - private final Collection<V> delegate; - private final Object monitor; - - public SynchronizedCollection(final Collection<V> delegate) { - this.delegate = delegate; - monitor = this; - } - - public SynchronizedCollection(final Collection<V> delegate, final Object monitor) { - this.delegate = delegate; - this.monitor = monitor; - } - - public int size() { - synchronized (monitor) { - return delegate.size(); - } - } - - public boolean isEmpty() { - synchronized (monitor) { - return delegate.isEmpty(); - } - } - - public boolean contains(final Object o) { - synchronized (monitor) { - return delegate.contains(o); - } - } - - public Iterator<V> iterator() { - synchronized (monitor) { - return new SynchronizedIterator<V>(delegate.iterator(), monitor); - } - } - - public Object[] toArray() { - synchronized (monitor) { - return delegate.toArray(); - } - } - - public <T> T[] toArray(final T[] a) { - synchronized (monitor) { - return delegate.toArray(a); - } - } - - public boolean add(final V o) { - synchronized (monitor) { - return delegate.add(o); - } - } - - public boolean remove(final Object o) { - synchronized (monitor) { - return delegate.remove(o); - } - } - - public boolean containsAll(final Collection<?> c) { - synchronized (monitor) { - return delegate.containsAll(c); - } - } - - public boolean addAll(final Collection<? extends V> c) { - synchronized (monitor) { - return delegate.addAll(c); - } - } - - public boolean removeAll(final Collection<?> c) { - synchronized (monitor) { - return delegate.removeAll(c); - } - } - - public boolean retainAll(final Collection<?> c) { - synchronized (monitor) { - return delegate.retainAll(c); - } - } - - public void clear() { - synchronized (monitor) { - delegate.clear(); - } - } - - public boolean equals(final Object o) { - synchronized (monitor) { - return delegate.equals(o); - } - } - - public int hashCode() { - synchronized (monitor) { - return delegate.hashCode(); - } - } - - public String toString() { - synchronized (monitor) { - return delegate.toString(); - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedIterator.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedIterator.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedIterator.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,52 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Iterator; - -/** - * - */ -public class SynchronizedIterator<T> implements Iterator<T> { - private final Iterator<T> delegate; - private final Object monitor; - - protected SynchronizedIterator(final Iterator<T> delegate, final Object monitor) { - this.delegate = delegate; - this.monitor = monitor; - } - - public boolean hasNext() { - synchronized (monitor) { - return delegate.hasNext(); - } - } - - public T next() { - synchronized (monitor) { - return delegate.next(); - } - } - - public void remove() { - synchronized (monitor) { - delegate.remove(); - } - } - - public int hashCode() { - synchronized (monitor) { - return delegate.hashCode(); - } - } - - public boolean equals(Object obj) { - synchronized (monitor) { - return delegate.equals(obj); - } - } - - public String toString() { - synchronized (monitor) { - return delegate.toString(); - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedMap.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedMap.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedMap.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,156 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Collection; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.ConcurrentMap; - -/** - * - */ -public class SynchronizedMap<K, V> implements ConcurrentMap<K, V> { - private final Object monitor; - private final Map<K, V> delegate; - - public SynchronizedMap(final Map<K, V> delegate) { - this.delegate = delegate; - monitor = this; - } - - protected SynchronizedMap(final Map<K, V> delegate, final Object monitor) { - this.monitor = monitor; - this.delegate = delegate; - } - - public int size() { - synchronized (monitor) { - return delegate.size(); - } - } - - public boolean isEmpty() { - synchronized (monitor) { - return delegate.isEmpty(); - } - } - - public boolean containsKey(final Object key) { - synchronized (monitor) { - return delegate.containsKey(key); - } - } - - public boolean containsValue(final Object value) { - synchronized (monitor) { - return delegate.containsValue(value); - } - } - - public V get(final Object key) { - synchronized (monitor) { - return delegate.get(key); - } - } - - public V put(final K key, final V value) { - synchronized (monitor) { - return delegate.put(key, value); - } - } - - public V remove(final Object key) { - synchronized (monitor) { - return delegate.remove(key); - } - } - - public void putAll(final Map<? extends K, ? extends V> t) { - synchronized (monitor) { - delegate.putAll(t); - } - } - - public void clear() { - synchronized (monitor) { - delegate.clear(); - } - } - - public Set<K> keySet() { - synchronized (monitor) { - return new SynchronizedSet<K>(delegate.keySet(), monitor); - } - } - - public Collection<V> values() { - synchronized (monitor) { - return new SynchronizedCollection<V>(delegate.values(), monitor); - } - } - - public Set<Entry<K, V>> entrySet() { - synchronized (monitor) { - return new SynchronizedSet<Entry<K, V>>(delegate.entrySet(), monitor); - } - } - - public boolean equals(final Object o) { - synchronized (monitor) { - return delegate.equals(o); - } - } - - public int hashCode() { - synchronized (monitor) { - return delegate.hashCode(); - } - } - - public V putIfAbsent(final K key, final V value) { - synchronized (monitor) { - if (delegate.containsKey(key)) { - return delegate.get(key); - } else { - return delegate.put(key, value); - } - } - } - - public boolean remove(final Object key, final Object value) { - synchronized (monitor) { - if (delegate.containsKey(key) && (value == null && delegate.get(key) == null || delegate.get(key).equals(value))) { - delegate.remove(key); - return true; - } else { - return false; - } - } - } - - public boolean replace(final K key, final V oldValue, final V newValue) { - synchronized (monitor) { - if (delegate.containsKey(key) && (oldValue == null ? delegate.get(key) == null : delegate.get(key).equals(oldValue))) { - delegate.put(key, newValue); - return true; - } else { - return false; - } - } - } - - public V replace(final K key, final V value) { - synchronized (monitor) { - if (delegate.containsKey(key)) { - return delegate.put(key, value); - } else { - return null; - } - } - } - - public String toString() { - synchronized (monitor) { - return delegate.toString(); - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedQueue.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedQueue.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedQueue.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,249 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Collection; -import java.util.Iterator; -import java.util.Queue; -import java.util.concurrent.BlockingQueue; -import java.util.concurrent.TimeUnit; - -/** - * - */ -public class SynchronizedQueue<T> implements BlockingQueue<T> { - private final Queue<T> delegate; - private final Object monitor; - - public SynchronizedQueue(final Queue<T> delegate) { - this.delegate = delegate; - monitor = this; - } - - protected SynchronizedQueue(final Queue<T> delegate, final Object monitor) { - this.monitor = monitor; - this.delegate = delegate; - } - - public boolean offer(final T o) { - synchronized(monitor) { - return delegate.offer(o); - } - } - - public T poll() { - synchronized(monitor) { - return delegate.poll(); - } - } - - public T remove() { - synchronized(monitor) { - return delegate.remove(); - } - } - - public T peek() { - synchronized(monitor) { - return delegate.peek(); - } - } - - public T element() { - synchronized(monitor) { - return delegate.element(); - } - } - - public int size() { - synchronized(monitor) { - return delegate.size(); - } - } - - public boolean isEmpty() { - synchronized(monitor) { - return delegate.isEmpty(); - } - } - - public boolean contains(final Object o) { - synchronized(monitor) { - return delegate.contains(o); - } - } - - public Iterator<T> iterator() { - synchronized(monitor) { - return delegate.iterator(); - } - } - - public Object[] toArray() { - synchronized(monitor) { - return delegate.toArray(); - } - } - - public <U> U[] toArray(final U[] a) { - synchronized(monitor) { - //noinspection SuspiciousToArrayCall - return delegate.toArray(a); - } - } - - public boolean add(final T o) { - synchronized(monitor) { - return delegate.add(o); - } - } - - public boolean remove(final Object o) { - synchronized(monitor) { - return delegate.remove(o); - } - } - - public boolean containsAll(final Collection<?> c) { - synchronized(monitor) { - return delegate.containsAll(c); - } - } - - public boolean addAll(final Collection<? extends T> c) { - synchronized(monitor) { - return delegate.addAll(c); - } - } - - public boolean removeAll(final Collection<?> c) { - synchronized(monitor) { - return delegate.removeAll(c); - } - } - - public boolean retainAll(final Collection<?> c) { - synchronized(monitor) { - return delegate.retainAll(c); - } - } - - public void clear() { - synchronized(monitor) { - delegate.clear(); - } - } - - public boolean equals(final Object o) { - synchronized(monitor) { - return delegate.equals(o); - } - } - - public int hashCode() { - synchronized(monitor) { - return delegate.hashCode(); - } - } - - public boolean offer(final T o, final long timeout, final TimeUnit unit) throws InterruptedException { - long startTime = System.currentTimeMillis(); - long timeoutMillis = unit.toMillis(timeout); - long deadline = startTime + timeoutMillis < 0L ? Long.MAX_VALUE : startTime + timeoutMillis; - synchronized(monitor) { - for (;;) { - if (offer(o)) { - return true; - } - if (deadline <= startTime) { - return false; - } - monitor.wait(deadline - startTime); - startTime = System.currentTimeMillis(); - } - } - } - - public T poll(final long timeout, final TimeUnit unit) throws InterruptedException { - long startTime = System.currentTimeMillis(); - long timeoutMillis = unit.toMillis(timeout); - long deadline = startTime + timeoutMillis < 0L ? Long.MAX_VALUE : startTime + timeoutMillis; - synchronized(monitor) { - for (;;) { - final T v = poll(); - if (v != null) { - return v; - } - if (deadline <= startTime) { - return null; - } - monitor.wait(deadline - startTime); - startTime = System.currentTimeMillis(); - } - } - } - - public T take() throws InterruptedException { - synchronized(monitor) { - for (;;) { - final T v = poll(); - if (v != null) { - return v; - } - monitor.wait(); - } - } - } - - public void put(final T o) throws InterruptedException { - synchronized(monitor) { - for(;;) { - if (add(o)) { - return; - } - monitor.wait(); - } - } - } - - public int remainingCapacity() { - return Integer.MAX_VALUE; - } - - public int drainTo(final Collection<? super T> c) { - if (c == this) { - throw new IllegalArgumentException("Attempt to drain queue to itself"); - } - int cnt = 0; - synchronized(monitor) { - for (;;) { - T v = poll(); - if (v == null) { - return cnt; - } else { - c.add(v); - cnt++; - } - } - } - } - - public int drainTo(final Collection<? super T> c, final int maxElements) { - if (c == this) { - throw new IllegalArgumentException("Attempt to drain queue to itself"); - } - int cnt = 0; - synchronized(monitor) { - for (;;) { - T v = poll(); - if (v == null) { - return cnt; - } else { - c.add(v); - cnt++; - if (cnt == maxElements) { - return cnt; - } - } - } - } - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedSet.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedSet.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/SynchronizedSet.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,17 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Set; - -/** - * - */ -public class SynchronizedSet<K> extends SynchronizedCollection<K> implements Set<K> { - - public SynchronizedSet(final Set<K> delegate) { - super(delegate); - } - - public SynchronizedSet(final Set<K> delegate, final Object monitor) { - super(delegate, monitor); - } -} Deleted: remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/WeakHashSet.java =================================================================== --- remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/WeakHashSet.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/core/src/main/java/org/jboss/remoting/core/util/WeakHashSet.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -1,76 +0,0 @@ -package org.jboss.remoting.core.util; - -import java.util.Collection; -import java.util.Iterator; -import java.util.Set; -import java.util.WeakHashMap; - -/** - * - */ -public final class WeakHashSet<T> implements Set<T> { - private final WeakHashMap<T,Void> map = new WeakHashMap<T,Void>(); - - public int size() { - return map.size(); - } - - public boolean isEmpty() { - return map.isEmpty(); - } - - public boolean contains(final Object o) { - return map.containsKey(o); - } - - public Iterator<T> iterator() { - return map.keySet().iterator(); - } - - public Object[] toArray() { - return map.keySet().toArray(); - } - - public <U> U[] toArray(final U[] a) { - return map.keySet().toArray(a); - } - - public boolean add(final T o) { - try { - return ! map.containsKey(o); - } finally { - map.put(o, null); - } - } - - public boolean remove(final Object o) { - return map.keySet().remove(o); - } - - public boolean containsAll(final Collection<?> c) { - return map.keySet().containsAll(c); - } - - public boolean addAll(final Collection<? extends T> c) { - boolean changed = false; - for (T t : c) { - if (! map.containsKey(t)) { - changed = true; - map.put(t, null); - } - } - return changed; - } - - public boolean retainAll(final Collection<?> c) { - return map.keySet().retainAll(c); - } - - public boolean removeAll(final Collection<?> c) { - return map.keySet().removeAll(c); - } - - public void clear() { - map.clear(); - } -} Modified: remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexClientExample.java =================================================================== --- remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexClientExample.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexClientExample.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -27,9 +27,9 @@ import org.jboss.remoting.ClientSource; import org.jboss.remoting.Client; import org.jboss.remoting.QualifiedName; -import org.jboss.remoting.protocol.multiplex.MultiplexProtocol; -import org.jboss.remoting.protocol.multiplex.MultiplexConfiguration; -import org.jboss.remoting.protocol.multiplex.MultiplexConnection; +import org.jboss.remoting.multiplex.MultiplexProtocol; +import org.jboss.remoting.multiplex.MultiplexConfiguration; +import org.jboss.remoting.multiplex.MultiplexConnection; import org.jboss.remoting.spi.NamedServiceRegistry; import org.jboss.remoting.spi.RequestHandlerSource; import org.jboss.remoting.spi.Handle; @@ -85,7 +85,7 @@ final CloseableTcpConnector closeableTcpConnector = tcpConnectorFactory.create(); try { final ChannelSource<AllocatedMessageChannel> channelSource = Channels.convertStreamToAllocatedMessage(closeableTcpConnector.createChannelSource(new InetSocketAddress("localhost", 10000)), 1024, 1024); - final IoFuture<MultiplexConnection> futureConnection = MultiplexProtocol.connect(endpoint, config, channelSource); + final IoFuture<MultiplexConnection> futureConnection = MultiplexProtocol.connect(config, channelSource); final MultiplexConnection connection = futureConnection.get(); try { final Handle<RequestHandlerSource> handle = connection.openRemoteService(QualifiedName.parse("/jboss/example/string-rot-13")); Modified: remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexServerExample.java =================================================================== --- remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexServerExample.java 2009-02-17 00:53:11 UTC (rev 4851) +++ remoting3/trunk/samples/src/main/java/org/jboss/remoting/samples/simple/MultiplexServerExample.java 2009-02-26 02:44:32 UTC (rev 4852) @@ -25,8 +25,8 @@ import org.jboss.remoting.Remoting; import org.jboss.remoting.Endpoint; import org.jboss.remoting.LocalServiceConfiguration; -import org.jboss.remoting.protocol.multiplex.MultiplexProtocol; -import org.jboss.remoting.protocol.multiplex.MultiplexConfiguration; +import org.jboss.remoting.multiplex.MultiplexProtocol; +import org.jboss.remoting.multiplex.MultiplexConfiguration; import org.jboss.remoting.spi.RequestHandlerSource; import org.jboss.remoting.spi.Handle; import org.jboss.remoting.spi.NamedServiceRegistry; @@ -88,7 +88,7 @@ final MarshallingConfiguration marshallingConfig = new MarshallingConfiguration(); marshallingConfig.setCreator(new SunReflectiveCreator()); multiplexConfig.setMarshallingConfiguration(marshallingConfig); - final IoHandlerFactory<AllocatedMessageChannel> handlerFactory = MultiplexProtocol.createServer(endpoint, multiplexConfig); + final IoHandlerFactory<AllocatedMessageChannel> handlerFactory = MultiplexProtocol.createServer(multiplexConfig); final IoHandlerFactory<StreamChannel> streamHandlerFactory = Channels.convertStreamToAllocatedMessage(handlerFactory, 1024, 1024); // finally, bind it final Xnio xnio = Xnio.create();