[jboss-remoting-commits] JBoss Remoting SVN: r4852 - in remoting3/trunk: core/src/main/java/org/jboss/remoting/core/util and 1 other directories.
jboss-remoting-commits at lists.jboss.org
jboss-remoting-commits at lists.jboss.org
Wed Feb 25 21:44:32 EST 2009
Author: david.lloyd at 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();
More information about the jboss-remoting-commits
mailing list