[jboss-cvs] JBossAS SVN: r111346 - in projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc: util and 1 other directory.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Wed May 11 17:15:54 EDT 2011
Author: jesper.pedersen
Date: 2011-05-11 17:15:53 -0400 (Wed, 11 May 2011)
New Revision: 111346
Added:
projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/BoundedConcurrentHashMap.java
Removed:
projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/LRUCachePolicy.java
Modified:
projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/BaseWrapperManagedConnection.java
projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/PreparedStatementCache.java
Log:
[JBJCA-574] Improve prepared statement cache
Modified: projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/BaseWrapperManagedConnection.java
===================================================================
--- projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/BaseWrapperManagedConnection.java 2011-05-11 19:12:01 UTC (rev 111345)
+++ projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/BaseWrapperManagedConnection.java 2011-05-11 21:15:53 UTC (rev 111346)
@@ -587,7 +587,7 @@
resultSetType,
resultSetConcurrency);
- CachedPreparedStatement cachedps = (CachedPreparedStatement) psCache.get(key);
+ CachedPreparedStatement cachedps = psCache.get(key);
if (cachedps != null)
{
if (canUse(cachedps))
@@ -607,7 +607,7 @@
{
PreparedStatement ps = doPrepareStatement(sql, resultSetType, resultSetConcurrency);
cachedps = WRAPPED_CONNECTION_FACTORY.createCachedPreparedStatement(ps);
- psCache.insert(key, cachedps);
+ psCache.put(key, cachedps);
mcf.getStatistics().deltaPreparedStatementCacheAddCount();
}
@@ -672,7 +672,7 @@
{
CallableStatement cs = doPrepareCall(sql, resultSetType, resultSetConcurrency);
cachedps = WRAPPED_CONNECTION_FACTORY.createCachedCallableStatement(cs);
- psCache.insert(key, cachedps);
+ psCache.put(key, cachedps);
mcf.getStatistics().deltaPreparedStatementCacheAddCount();
}
return cachedps;
Modified: projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/PreparedStatementCache.java
===================================================================
--- projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/PreparedStatementCache.java 2011-05-11 19:12:01 UTC (rev 111345)
+++ projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/PreparedStatementCache.java 2011-05-11 21:15:53 UTC (rev 111346)
@@ -23,26 +23,27 @@
package org.jboss.jca.adapters.jdbc;
import org.jboss.jca.adapters.jdbc.statistics.JdbcStatisticsPlugin;
-import org.jboss.jca.adapters.jdbc.util.LRUCachePolicy;
+import org.jboss.jca.adapters.jdbc.util.BoundedConcurrentHashMap;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.util.Iterator;
+import java.util.Map;
import org.jboss.logging.Logger;
/**
- * LRU cache for PreparedStatements. When ps ages out, close it.
+ * Cache for PreparedStatements. When ps ages out, close it.
*
- * @author <a href="mailto:bill at jboss.org">Bill Burke</a>
- * @author <a href="mailto:adrian at jboss.com">Adrian Brock</a>
- * @author Scott.Stark at jboss.org
- * @version $Revision: 73034 $
+ * @author <a href="mailto:jesper.pedersen at jboss.org">Jesper Pedersen</a>
*/
-public class PreparedStatementCache extends LRUCachePolicy
+ at SuppressWarnings("unchecked")
+public class PreparedStatementCache
{
private final Logger log = Logger.getLogger(getClass());
+ private BoundedConcurrentHashMap<Key, CachedPreparedStatement> cache;
private JdbcStatisticsPlugin statistics;
/**
@@ -177,33 +178,91 @@
*/
public PreparedStatementCache(int max, JdbcStatisticsPlugin stats)
{
- super(2, max);
- create();
+ BoundedConcurrentHashMap.EvictionListener evictionListener =
+ new PreparedStatementEvictionListener(stats, log);
+ this.cache =
+ new BoundedConcurrentHashMap<Key, CachedPreparedStatement>(max, 16,
+ BoundedConcurrentHashMap.Eviction.LIRS,
+ evictionListener);
this.statistics = stats;
}
/**
- * Age out an entry
- * @param entry The entry
+ * Get
+ * @param key The key
+ * @return The value
*/
- @Override
- protected void ageOut(LRUCachePolicy.LRUCacheEntry entry)
+ public CachedPreparedStatement get(Key key)
{
- try
+ return cache.get(key);
+ }
+
+ /**
+ * Put
+ * @param key The key
+ * @param value The value
+ */
+ public void put(Key key, CachedPreparedStatement value)
+ {
+ cache.put(key, value);
+ }
+
+ /**
+ * Size
+ * @return The size
+ */
+ public int size()
+ {
+ return cache.size();
+ }
+
+ /**
+ * Prepared statement eviction listener
+ */
+ static class PreparedStatementEvictionListener implements BoundedConcurrentHashMap.EvictionListener
+ {
+ private JdbcStatisticsPlugin statistics;
+ private Logger log;
+
+ /**
+ * Constructor
+ * @param stats The statistics
+ * @param log The logger
+ */
+ public PreparedStatementEvictionListener(JdbcStatisticsPlugin stats, Logger log)
{
- CachedPreparedStatement ws = (CachedPreparedStatement) entry.getObject();
- ws.agedOut();
+ this.statistics = stats;
+ this.log = log;
}
- catch (SQLException e)
+
+ /**
+ * Entry eviction
+ * @param evicted The entry
+ */
+ public void onEntryEviction(Map evicted)
{
- log.debug("Failed closing cached statement", e);
+ if (evicted != null)
+ {
+ Iterator it = evicted.values().iterator();
+ while (it.hasNext())
+ {
+ try
+ {
+ CachedPreparedStatement ws = (CachedPreparedStatement)it.next();
+ ws.agedOut();
+ }
+ catch (SQLException e)
+ {
+ log.debug("Failed closing cached statement", e);
+ }
+ finally
+ {
+ statistics.deltaPreparedStatementCacheDeleteCount();
+ }
+ }
+ }
}
- finally
- {
- super.ageOut(entry);
- statistics.deltaPreparedStatementCacheDeleteCount();
- }
}
/**
@@ -212,13 +271,13 @@
@Override
public String toString()
{
- String s = " PreparedStatementCache size: " + lruList.getCount();
- for (LRUCacheEntry entry = lruList.getHead(); entry != null; entry = entry.getNext())
+ StringBuilder sb = new StringBuilder("PreparedStatementCache size: ").append(size()).append(" ");
+ Iterator<Key> it = cache.keySet().iterator();
+ while (it.hasNext())
{
- CachedPreparedStatement ws = (CachedPreparedStatement) entry.getObject();
- PreparedStatementCache.Key key = (PreparedStatementCache.Key) entry.getKey();
- s += "[" + key.getSql() + "] ";
+ Key key = it.next();
+ sb.append("[").append(key.getSql()).append("] ");
}
- return s + "\n";
+ return sb.toString();
}
}
Added: projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/BoundedConcurrentHashMap.java
===================================================================
--- projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/BoundedConcurrentHashMap.java (rev 0)
+++ projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/BoundedConcurrentHashMap.java 2011-05-11 21:15:53 UTC (rev 111346)
@@ -0,0 +1,2739 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2011, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file 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.jca.adapters.jdbc.util;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.AbstractCollection;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * A hash table supporting full concurrency of retrievals and
+ * adjustable expected concurrency for updates. 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>.
+ *
+ * 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
+ *
+ * Modified for https://jira.jboss.org/jira/browse/ISPN-299
+ * Includes ideas described in http://portal.acm.org/citation.cfm?id=1547428
+ *
+ * @since 1.5
+ * @author Doug Lea
+ * @param <K> the type of keys maintained by this map
+ * @param <V> the type of mapped values
+ */
+public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V> implements 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.
+ */
+
+ /* ---------------- Constants -------------- */
+
+ /**
+ * The default initial capacity for this table,
+ * used when not otherwise specified in a constructor.
+ */
+ static final int DEFAULT_MAXIMUM_CAPACITY = 512;
+
+ /**
+ * 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;
+
+ /** Key set */
+ transient Set<K> keySet;
+
+ /** Entry set */
+ transient Set<Map.Entry<K, V>> entrySet;
+
+ /** Values */
+ 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 ConcurrentHashMap 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];
+ }
+
+ /* ---------------- Inner Classes -------------- */
+
+ /**
+ * ConcurrentHashMap 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>
+ {
+ /** Key */
+ final K key;
+
+ /** Hash */
+ final int hash;
+
+ /** Value */
+ volatile V value;
+
+ /** Entry */
+ final HashEntry<K, V> next;
+
+ /** State */
+ volatile Recency state;
+
+ /**
+ * Constructor
+ * @param key The key
+ * @param hash The hash
+ * @param next Next pointer
+ * @param value The value
+ */
+ HashEntry(K key, int hash, HashEntry<K, V> next, V value)
+ {
+ this.key = key;
+ this.hash = hash;
+ this.next = next;
+ this.value = value;
+ this.state = Recency.HIR_RESIDENT;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode()
+ {
+ int result = 17;
+ result = result * 31 + hash;
+ result = result * 31 + key.hashCode();
+ return result;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals(Object o)
+ {
+ // HashEntry is internal class, never leaks out of CHM, hence slight optimization
+ if (this == o)
+ {
+ return true;
+ }
+ if (o == null)
+ {
+ return false;
+ }
+ HashEntry<?, ?> other = (HashEntry<?, ?>) o;
+ return hash == other.hash && key.equals(other.key);
+ }
+
+ /**
+ * State: LIR_RESIDENT
+ */
+ public void transitionToLIRResident()
+ {
+ state = Recency.LIR_RESIDENT;
+ }
+
+ /**
+ * State: HIR_NONRESIDENT
+ */
+ public void transitionHIRResidentToHIRNonResident()
+ {
+ state = Recency.HIR_NONRESIDENT;
+ }
+
+ /**
+ * State: HIR_RESIDENT
+ */
+ public void transitionLIRResidentToHIRResident()
+ {
+ state = Recency.HIR_RESIDENT;
+ }
+
+ /**
+ * Recency
+ * @return The value
+ */
+ public Recency recency()
+ {
+ return state;
+ }
+
+ /**
+ * New array
+ * @param i The index
+ * @return The entry
+ */
+ @SuppressWarnings("unchecked")
+ static <K, V> HashEntry<K, V>[] newArray(int i)
+ {
+ return new HashEntry[i];
+ }
+ }
+
+ private enum Recency
+ {
+ HIR_RESIDENT, LIR_RESIDENT, HIR_NONRESIDENT
+ }
+
+ /**
+ * Eviction
+ */
+ public enum Eviction
+ {
+ /** None */
+ NONE
+ {
+ @Override
+ public <K, V> EvictionPolicy<K, V> make(Segment<K, V> s, int capacity, float lf)
+ {
+ return new NullEvictionPolicy<K, V>();
+ }
+ },
+ /** LRU */
+ LRU
+ {
+ @Override
+ public <K, V> EvictionPolicy<K, V> make(Segment<K, V> s, int capacity, float lf)
+ {
+ return new LRU<K, V>(s, capacity, lf, capacity * 10, lf);
+ }
+ },
+ /** LIRS */
+ LIRS
+ {
+ @Override
+ public <K, V> EvictionPolicy<K, V> make(Segment<K, V> s, int capacity, float lf)
+ {
+ return new LIRS<K, V>(s, capacity, capacity * 10, lf);
+ }
+ };
+
+ /**
+ * Make
+ * @param s The segment
+ * @param capacity The capacity
+ * @param lf The load factor
+ * @return The policy
+ */
+ abstract <K, V> EvictionPolicy<K, V> make(Segment<K, V> s, int capacity, float lf);
+ }
+
+ /**
+ * Eviction listener
+ */
+ public interface EvictionListener<K, V>
+ {
+ /**
+ * Entry eviction
+ * @param evicted The entry
+ */
+ void onEntryEviction(Map<K, V> evicted);
+ }
+
+ /**
+ * Null eviction listener
+ */
+ static class NullEvictionListener<K, V> implements EvictionListener<K, V>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void onEntryEviction(Map<K, V> evicted)
+ {
+ // Do nothing.
+ }
+ }
+
+ /**
+ * Eviction policy
+ */
+ public interface EvictionPolicy<K, V>
+ {
+ /** Max batch size */
+ public static final int MAX_BATCH_SIZE = 64;
+
+ /**
+ * Invokes eviction policy algorithm and returns set of evicted entries.
+ *
+ * <p>
+ * Set cannot be null but could possibly be an empty set.
+ *
+ * @return set of evicted entries.
+ */
+ Set<HashEntry<K, V>> execute();
+
+ /**
+ * Invoked to notify EvictionPolicy implementation that there has been an attempt to access
+ * an entry in Segment, however that entry was not present in Segment.
+ *
+ * @param e
+ * accessed entry in Segment
+ *
+ * @return non null set of evicted entries.
+ */
+ Set<HashEntry<K, V>> onEntryMiss(HashEntry<K, V> e);
+
+ /**
+ * Invoked to notify EvictionPolicy implementation that an entry in Segment has been
+ * accessed. Returns true if batching threshold has been reached, false otherwise.
+ * <p>
+ * Note that this method is potentially invoked without holding a lock on Segment.
+ *
+ * @return true if batching threshold has been reached, false otherwise.
+ *
+ * @param e
+ * accessed entry in Segment
+ */
+ boolean onEntryHit(HashEntry<K, V> e);
+
+ /**
+ * Invoked to notify EvictionPolicy implementation that an entry e has been removed from
+ * Segment.
+ *
+ * @param e
+ * removed entry in Segment
+ */
+ void onEntryRemove(HashEntry<K, V> e);
+
+ /**
+ * Invoked to notify EvictionPolicy implementation that all Segment entries have been
+ * cleared.
+ *
+ */
+ void clear();
+
+ /**
+ * Returns type of eviction algorithm (strategy).
+ *
+ * @return type of eviction algorithm
+ */
+ Eviction strategy();
+
+ /**
+ * Returns true if batching threshold has expired, false otherwise.
+ * <p>
+ * Note that this method is potentially invoked without holding a lock on Segment.
+ *
+ * @return true if batching threshold has expired, false otherwise.
+ */
+ boolean thresholdExpired();
+ }
+
+ /**
+ * Null eviction policy
+ */
+ static class NullEvictionPolicy<K, V> implements EvictionPolicy<K, V>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void clear()
+ {
+ // Do nothing.
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Set<HashEntry<K, V>> execute()
+ {
+ return Collections.emptySet();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean onEntryHit(HashEntry<K, V> e)
+ {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Set<HashEntry<K, V>> onEntryMiss(HashEntry<K, V> e)
+ {
+ return Collections.emptySet();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void onEntryRemove(HashEntry<K, V> e)
+ {
+ // Do nothing.
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean thresholdExpired()
+ {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Eviction strategy()
+ {
+ return Eviction.NONE;
+ }
+ }
+
+ /**
+ * LRU
+ */
+ static final class LRU<K, V> implements EvictionPolicy<K, V>
+ {
+ private final ConcurrentLinkedQueue<HashEntry<K, V>> accessQueue;
+ private final Segment<K, V> segment;
+ private final LinkedList<HashEntry<K, V>> lruQueue;
+ private final int maxBatchQueueSize;
+ private final int trimDownSize;
+ private final float batchThresholdFactor;
+
+ /**
+ * LRU
+ * @param s The segment
+ * @param capacity The capacity
+ * @param lf The load factor
+ * @param maxBatchSize The max batch size
+ * @param batchThresholdFactor The batch threshold factor
+ */
+ public LRU(Segment<K, V> s, int capacity, float lf, int maxBatchSize, float batchThresholdFactor)
+ {
+ this.segment = s;
+ this.trimDownSize = (int) (capacity * lf);
+ this.maxBatchQueueSize = maxBatchSize > MAX_BATCH_SIZE ? MAX_BATCH_SIZE : maxBatchSize;
+ this.batchThresholdFactor = batchThresholdFactor;
+ this.accessQueue = new ConcurrentLinkedQueue<HashEntry<K, V>>();
+ this.lruQueue = new LinkedList<HashEntry<K, V>>();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Set<HashEntry<K, V>> execute()
+ {
+ Set<HashEntry<K, V>> evicted = Collections.emptySet();
+ if (isOverflow())
+ {
+ evicted = new HashSet<HashEntry<K, V>>();
+ }
+ try
+ {
+ for (HashEntry<K, V> e : accessQueue)
+ {
+ if (lruQueue.remove(e))
+ {
+ lruQueue.addFirst(e);
+ }
+ }
+ while (isOverflow())
+ {
+ HashEntry<K, V> first = lruQueue.getLast();
+ segment.remove(first.key, first.hash, null);
+ evicted.add(first);
+ }
+ }
+ finally
+ {
+ accessQueue.clear();
+ }
+ return evicted;
+ }
+
+ private boolean isOverflow()
+ {
+ return lruQueue.size() > trimDownSize;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Set<HashEntry<K, V>> onEntryMiss(HashEntry<K, V> e)
+ {
+ lruQueue.addFirst(e);
+ return Collections.emptySet();
+ }
+
+ /*
+ * Invoked without holding a lock on Segment
+ */
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean onEntryHit(HashEntry<K, V> e)
+ {
+ accessQueue.add(e);
+ return accessQueue.size() >= maxBatchQueueSize * batchThresholdFactor;
+ }
+
+ /*
+ * Invoked without holding a lock on Segment
+ */
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean thresholdExpired()
+ {
+ return accessQueue.size() >= maxBatchQueueSize;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void onEntryRemove(HashEntry<K, V> e)
+ {
+ lruQueue.remove(e);
+ // we could have multiple instances of e in accessQueue; remove them all
+ while (accessQueue.remove(e))
+ {
+ continue;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void clear()
+ {
+ lruQueue.clear();
+ accessQueue.clear();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Eviction strategy()
+ {
+ return Eviction.LRU;
+ }
+ }
+
+ /**
+ * LIRS
+ */
+ static final class LIRS<K, V> implements EvictionPolicy<K, V>
+ {
+ private static final int MIN_HIR_SIZE = 2;
+ private final Segment<K, V> segment;
+ private final ConcurrentLinkedQueue<HashEntry<K, V>> accessQueue;
+ private final LinkedHashMap<K, HashEntry<K, V>> stack;
+ private final LinkedList<HashEntry<K, V>> queue;
+ private final int maxBatchQueueSize;
+ private final int lirSizeLimit;
+ private final int hirSizeLimit;
+ private int currentLIRSize;
+ private final float batchThresholdFactor;
+
+ /**
+ * LIRS
+ * @param s The segment
+ * @param capacity The capacity
+ * @param maxBatchSize The max batch size
+ * @param batchThresholdFactor The batch threshold factor
+ */
+ public LIRS(Segment<K, V> s, int capacity, int maxBatchSize, float batchThresholdFactor)
+ {
+ this.segment = s;
+ int tmpLirSize = (int) (capacity * 0.9);
+ int tmpHirSizeLimit = capacity - tmpLirSize;
+ if (tmpHirSizeLimit < MIN_HIR_SIZE)
+ {
+ hirSizeLimit = MIN_HIR_SIZE;
+ lirSizeLimit = capacity - hirSizeLimit;
+ }
+ else
+ {
+ hirSizeLimit = tmpHirSizeLimit;
+ lirSizeLimit = tmpLirSize;
+ }
+ this.maxBatchQueueSize = maxBatchSize > MAX_BATCH_SIZE ? MAX_BATCH_SIZE : maxBatchSize;
+ this.batchThresholdFactor = batchThresholdFactor;
+ this.accessQueue = new ConcurrentLinkedQueue<HashEntry<K, V>>();
+ this.stack = new LinkedHashMap<K, HashEntry<K, V>>();
+ this.queue = new LinkedList<HashEntry<K, V>>();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Set<HashEntry<K, V>> execute()
+ {
+ Set<HashEntry<K, V>> evicted = new HashSet<HashEntry<K, V>>();
+ try
+ {
+ for (HashEntry<K, V> e : accessQueue)
+ {
+ if (present(e))
+ {
+ if (e.recency() == Recency.LIR_RESIDENT)
+ {
+ handleLIRHit(e, evicted);
+ }
+ else if (e.recency() == Recency.HIR_RESIDENT)
+ {
+ handleHIRHit(e, evicted);
+ }
+ }
+ }
+ removeFromSegment(evicted);
+ }
+ finally
+ {
+ accessQueue.clear();
+ }
+ return evicted;
+ }
+
+ private void handleHIRHit(HashEntry<K, V> e, Set<HashEntry<K, V>> evicted)
+ {
+ boolean inStack = stack.containsKey(e.key);
+ if (inStack)
+ {
+ stack.remove(e.key);
+ }
+
+ // first put on top of the stack
+ stack.put(e.key, e);
+
+ if (inStack)
+ {
+ queue.remove(e);
+ e.transitionToLIRResident();
+ switchBottomostLIRtoHIRAndPrune(evicted);
+ }
+ else
+ {
+ queue.remove(e);
+ queue.addLast(e);
+ }
+ }
+
+ private void handleLIRHit(HashEntry<K, V> e, Set<HashEntry<K, V>> evicted)
+ {
+ stack.remove(e.key);
+ stack.put(e.key, e);
+ for (Iterator<HashEntry<K, V>> i = stack.values().iterator(); i.hasNext();)
+ {
+ HashEntry<K, V> next = i.next();
+ if (next.recency() == Recency.LIR_RESIDENT)
+ {
+ break;
+ }
+ else
+ {
+ i.remove();
+ evicted.add(next);
+ }
+ }
+ }
+
+ private boolean present(HashEntry<K, V> e)
+ {
+ return stack.containsKey(e.key) || queue.contains(e);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Set<HashEntry<K, V>> onEntryMiss(HashEntry<K, V> e)
+ {
+ // initialization
+ Set<HashEntry<K, V>> evicted = Collections.emptySet();
+ if (currentLIRSize + 1 < lirSizeLimit)
+ {
+ currentLIRSize++;
+ e.transitionToLIRResident();
+ stack.put(e.key, e);
+ }
+ else
+ {
+ if (queue.size() < hirSizeLimit)
+ {
+ queue.addLast(e);
+ }
+ else
+ {
+ boolean inStack = stack.containsKey(e.key);
+ HashEntry<K, V> first = queue.removeFirst();
+ first.transitionHIRResidentToHIRNonResident();
+
+ stack.put(e.key, e);
+
+ evicted = new HashSet<HashEntry<K, V>>();
+ if (inStack)
+ {
+ e.transitionToLIRResident();
+ switchBottomostLIRtoHIRAndPrune(evicted);
+ }
+ else
+ {
+ queue.addLast(e);
+ evicted.add(first);
+ }
+ // evict from segment
+ removeFromSegment(evicted);
+ }
+ }
+ return evicted;
+ }
+
+ private void removeFromSegment(Set<HashEntry<K, V>> evicted)
+ {
+ for (HashEntry<K, V> e : evicted)
+ {
+ segment.remove(e.key, e.hash, null);
+ }
+ }
+
+ private void switchBottomostLIRtoHIRAndPrune(Set<HashEntry<K, V>> evicted)
+ {
+ boolean seenFirstLIR = false;
+ for (Iterator<HashEntry<K, V>> i = stack.values().iterator(); i.hasNext();)
+ {
+ HashEntry<K, V> next = i.next();
+ if (next.recency() == Recency.LIR_RESIDENT)
+ {
+ if (!seenFirstLIR)
+ {
+ seenFirstLIR = true;
+ i.remove();
+ next.transitionLIRResidentToHIRResident();
+ queue.addLast(next);
+ }
+ else
+ {
+ break;
+ }
+ }
+ else
+ {
+ i.remove();
+ evicted.add(next);
+ }
+ }
+ }
+
+ /*
+ * Invoked without holding a lock on Segment
+ */
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean onEntryHit(HashEntry<K, V> e)
+ {
+ accessQueue.add(e);
+ return accessQueue.size() >= maxBatchQueueSize * batchThresholdFactor;
+ }
+
+ /*
+ * Invoked without holding a lock on Segment
+ */
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean thresholdExpired()
+ {
+ return accessQueue.size() >= maxBatchQueueSize;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void onEntryRemove(HashEntry<K, V> e)
+ {
+ HashEntry<K, V> removed = stack.remove(e.key);
+ if (removed != null && removed.recency() == Recency.LIR_RESIDENT)
+ {
+ currentLIRSize--;
+ }
+ queue.remove(e);
+ // we could have multiple instances of e in accessQueue; remove them all
+ while (accessQueue.remove(e))
+ {
+ continue;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void clear()
+ {
+ stack.clear();
+ accessQueue.clear();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Eviction strategy()
+ {
+ return Eviction.LIRS;
+ }
+ }
+
+ /**
+ * 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
+ {
+ /*
+ * 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 eviction policy */
+ final transient EvictionPolicy<K, V> eviction;
+
+ /** The eviction listener */
+ final transient EvictionListener<K, V> evictionListener;
+
+ /**
+ * Constructor
+ * @param cap The capacity
+ * @param lf The load factor
+ * @param es The eviction
+ * @param listener The eviction listener
+ */
+ Segment(int cap, float lf, Eviction es, EvictionListener<K, V> listener)
+ {
+ loadFactor = lf;
+ eviction = es.make(this, cap, lf);
+ evictionListener = listener;
+ setTable(HashEntry.<K, V> newArray(cap));
+ }
+
+ /**
+ * New array
+ * @param i The index
+ * @return The segment
+ */
+ @SuppressWarnings("unchecked")
+ static final <K, V> Segment<K, V>[] newArray(int i)
+ {
+ return new Segment[i];
+ }
+
+ /**
+ * Eviction listener
+ * @return The value
+ */
+ EvictionListener<K, V> getEvictionListener()
+ {
+ return evictionListener;
+ }
+
+ /**
+ * Sets table to new HashEntry array.
+ * Call only while holding lock or in constructor.
+ * @param newTable The new table
+ */
+ void setTable(HashEntry<K, V>[] newTable)
+ {
+ threshold = (int)(newTable.length * loadFactor);
+ table = newTable;
+ }
+
+ /**
+ * Returns properly casted first entry of bin for given hash.
+ * @param hash The hash
+ * @return The entry
+ */
+ HashEntry<K, V> getFirst(int hash)
+ {
+ HashEntry<K, V>[] tab = table;
+ return tab[hash & tab.length - 1];
+ }
+
+ /**
+ * 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.
+ * @param e The entry
+ * @return The value
+ */
+ V readValueUnderLock(HashEntry<K, V> e)
+ {
+ lock();
+ try
+ {
+ return e.value;
+ }
+ finally
+ {
+ unlock();
+ }
+ }
+
+ /* Specialized implementations of map methods */
+
+ /**
+ * Get
+ * @param key The key
+ * @param hash The hash
+ * @return The value
+ */
+ V get(Object key, int hash)
+ {
+ int c = count;
+ if (c != 0) // read-volatile
+ {
+ V result = null;
+ HashEntry<K, V> e = getFirst(hash);
+ loop:
+ while (e != null)
+ {
+ if (e.hash == hash && key.equals(e.key))
+ {
+ V v = e.value;
+ if (v != null)
+ {
+ result = v;
+ break loop;
+ }
+ else
+ {
+ result = readValueUnderLock(e); // recheck
+ break loop;
+ }
+ }
+ e = e.next;
+ }
+ // a hit
+ if (result != null)
+ {
+ if (eviction.onEntryHit(e))
+ {
+ Set<HashEntry<K, V>> evicted = attemptEviction(false);
+ notifyEvictionListener(evicted);
+ }
+ }
+ return result;
+ }
+ return null;
+ }
+
+ /**
+ * Constains key
+ * @param key The key
+ * @param hash The hash
+ * @return True if present
+ */
+ boolean containsKey(Object key, int hash)
+ {
+ if (count != 0) // read-volatile
+ {
+ HashEntry<K, V> e = getFirst(hash);
+ while (e != null)
+ {
+ if (e.hash == hash && key.equals(e.key))
+ {
+ return true;
+ }
+ e = e.next;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Constains value
+ * @param value The value
+ * @return True if present
+ */
+ 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)
+ {
+ V v = e.value;
+ if (v == null)
+ {
+ v = readValueUnderLock(e);
+ }
+ if (value.equals(v))
+ {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Replace
+ * @param key The key
+ * @param hash The hash
+ * @param oldValue The old value
+ * @param newValue The new value
+ * @return True if replaced
+ */
+ boolean replace(K key, int hash, V oldValue, V newValue)
+ {
+ lock();
+ Set<HashEntry<K, V>> evicted = null;
+ try
+ {
+ HashEntry<K, V> e = getFirst(hash);
+ while (e != null && (e.hash != hash || !key.equals(e.key)))
+ {
+ e = e.next;
+ }
+
+ boolean replaced = false;
+ if (e != null && oldValue.equals(e.value))
+ {
+ replaced = true;
+ e.value = newValue;
+ if (eviction.onEntryHit(e))
+ {
+ evicted = attemptEviction(true);
+ }
+ }
+ return replaced;
+ }
+ finally
+ {
+ unlock();
+ notifyEvictionListener(evicted);
+ }
+ }
+
+ /**
+ * Replace
+ * @param key The key
+ * @param hash The hash
+ * @param newValue The new value
+ * @return The value
+ */
+ V replace(K key, int hash, V newValue)
+ {
+ lock();
+ Set<HashEntry<K, V>> evicted = null;
+ try
+ {
+ HashEntry<K, V> e = getFirst(hash);
+ while (e != null && (e.hash != hash || !key.equals(e.key)))
+ {
+ e = e.next;
+ }
+
+ V oldValue = null;
+ if (e != null)
+ {
+ oldValue = e.value;
+ e.value = newValue;
+ if (eviction.onEntryHit(e))
+ {
+ evicted = attemptEviction(true);
+ }
+ }
+ return oldValue;
+ }
+ finally
+ {
+ unlock();
+ notifyEvictionListener(evicted);
+ }
+ }
+
+ /**
+ * Put
+ * @param key The key
+ * @param hash The hash
+ * @param value The value
+ * @param onlyIfAbsent True; put if key doesn't exists
+ * @return The value
+ */
+ V put(K key, int hash, V value, boolean onlyIfAbsent)
+ {
+ lock();
+ Set<HashEntry<K, V>> evicted = null;
+ try
+ {
+ int c = count;
+ if (c++ > threshold && eviction.strategy() == Eviction.NONE)
+ {
+ rehash();
+ }
+ 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 || !key.equals(e.key)))
+ {
+ e = e.next;
+ }
+
+ V oldValue;
+ if (e != null)
+ {
+ oldValue = e.value;
+ if (!onlyIfAbsent)
+ {
+ e.value = value;
+ eviction.onEntryHit(e);
+ }
+ }
+ else
+ {
+ oldValue = null;
+ ++modCount;
+ count = c; // write-volatile
+ if (eviction.strategy() != Eviction.NONE)
+ {
+ if (c > tab.length)
+ {
+ // remove entries;lower count
+ evicted = eviction.execute();
+ // re-read first
+ first = tab[index];
+ }
+ // add a new entry
+ tab[index] = new HashEntry<K, V>(key, hash, first, value);
+ // notify a miss
+ Set<HashEntry<K, V>> newlyEvicted = eviction.onEntryMiss(tab[index]);
+ if (!newlyEvicted.isEmpty())
+ {
+ if (evicted != null)
+ {
+ evicted.addAll(newlyEvicted);
+ }
+ else
+ {
+ evicted = newlyEvicted;
+ }
+ }
+ }
+ else
+ {
+ tab[index] = new HashEntry<K, V>(key, hash, first, value);
+ }
+ }
+ return oldValue;
+ }
+ finally
+ {
+ unlock();
+ notifyEvictionListener(evicted);
+ }
+ }
+
+ /**
+ * Rehash
+ */
+ void rehash()
+ {
+ HashEntry<K, V>[] oldTable = table;
+ int oldCapacity = oldTable.length;
+ if (oldCapacity >= MAXIMUM_CAPACITY)
+ {
+ return;
+ }
+
+ /*
+ * 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;
+ 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)
+ {
+ int k = p.hash & sizeMask;
+ HashEntry<K, V> n = newTable[k];
+ newTable[k] = new HashEntry<K, V>(p.key, p.hash, n, p.value);
+ }
+ }
+ }
+ }
+ table = newTable;
+ }
+
+ /**
+ * Remove; match on key only if value null, else match both.
+ * @param key The key
+ * @param hash The hash
+ * @param value The value
+ * @return The value
+ */
+ V remove(Object key, int hash, Object value)
+ {
+ lock();
+ try
+ {
+ 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;
+ while (e != null && (e.hash != hash || !key.equals(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;
+
+ // e was removed
+ eviction.onEntryRemove(e);
+
+ HashEntry<K, V> newFirst = e.next;
+ for (HashEntry<K, V> p = first; p != e; p = p.next)
+ {
+ // allow p to be GC-ed
+ eviction.onEntryRemove(p);
+ newFirst = new HashEntry<K, V>(p.key, p.hash, newFirst, p.value);
+ // and notify eviction algorithm about new hash entries
+ eviction.onEntryMiss(newFirst);
+ }
+
+ tab[index] = newFirst;
+ count = c; // write-volatile
+ }
+ }
+ return oldValue;
+ }
+ finally
+ {
+ unlock();
+ }
+ }
+
+ /**
+ * Clear
+ */
+ void clear()
+ {
+ if (count != 0)
+ {
+ lock();
+ try
+ {
+ HashEntry<K, V>[] tab = table;
+ for (int i = 0; i < tab.length; i++)
+ {
+ tab[i] = null;
+ }
+ ++modCount;
+ eviction.clear();
+ count = 0; // write-volatile
+ }
+ finally
+ {
+ unlock();
+ }
+ }
+ }
+
+ private Set<HashEntry<K, V>> attemptEviction(boolean lockedAlready)
+ {
+ Set<HashEntry<K, V>> evicted = null;
+ boolean obtainedLock = !lockedAlready ? tryLock() : true;
+ if (!obtainedLock && eviction.thresholdExpired())
+ {
+ lock();
+ obtainedLock = true;
+ }
+ if (obtainedLock)
+ {
+ try
+ {
+ evicted = eviction.execute();
+ }
+ finally
+ {
+ if (!lockedAlready)
+ {
+ unlock();
+ }
+ }
+ }
+ return evicted;
+ }
+
+ private void notifyEvictionListener(Set<HashEntry<K, V>> evicted)
+ {
+ // piggyback listener invocation on callers thread outside lock
+ if (evicted != null)
+ {
+ Map<K, V> evictedCopy;
+ if (evicted.size() == 1)
+ {
+ HashEntry<K, V> evictedEntry = evicted.iterator().next();
+ evictedCopy = Collections.singletonMap(evictedEntry.key, evictedEntry.value);
+ }
+ else
+ {
+ evictedCopy = new HashMap<K, V>(evicted.size());
+ for (HashEntry<K, V> he : evicted)
+ {
+ evictedCopy.put(he.key, he.value);
+ }
+ evictedCopy = Collections.unmodifiableMap(evictedCopy);
+ }
+ evictionListener.onEntryEviction(evictedCopy);
+ }
+ }
+ }
+
+
+ /* ---------------- Public operations -------------- */
+
+
+ /**
+ * Creates a new, empty map with the specified maximum capacity, load factor and concurrency
+ * level.
+ *
+ * @param capacity
+ * is the upper bound capacity for the number of elements in this map
+ *
+ * @param concurrencyLevel
+ * the estimated number of concurrently updating threads. The implementation performs
+ * internal sizing to try to accommodate this many threads.
+ *
+ * @param evictionStrategy
+ * the algorithm used to evict elements from this map
+ *
+ * @param evictionListener
+ * the evicton listener callback to be notified about evicted elements
+ *
+ * @throws IllegalArgumentException
+ * if the initial capacity is negative or the load factor or concurrencyLevel are
+ * nonpositive.
+ */
+ public BoundedConcurrentHashMap(int capacity, int concurrencyLevel,
+ Eviction evictionStrategy, EvictionListener<K, V> evictionListener)
+ {
+ if (capacity < 0 || concurrencyLevel <= 0)
+ {
+ throw new IllegalArgumentException();
+ }
+
+ concurrencyLevel = Math.min(capacity / 2, concurrencyLevel); // concurrencyLevel cannot be > capacity/2
+ concurrencyLevel = Math.max(concurrencyLevel, 1); // concurrencyLevel cannot be less than 1
+
+ // minimum two elements per segment
+ if (capacity < concurrencyLevel * 2 && capacity != 1)
+ {
+ throw new IllegalArgumentException("Maximum capacity has to be at least twice the concurrencyLevel");
+ }
+
+ if (evictionStrategy == null || evictionListener == null)
+ {
+ 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 (capacity > MAXIMUM_CAPACITY)
+ {
+ capacity = MAXIMUM_CAPACITY;
+ }
+ int c = capacity / ssize;
+ if (c * ssize < capacity)
+ {
+ ++c;
+ }
+ int cap = 1;
+ while (cap < c)
+ {
+ cap <<= 1;
+ }
+
+ for (int i = 0; i < this.segments.length; ++i)
+ {
+ this.segments[i] = new Segment<K, V>(cap, DEFAULT_LOAD_FACTOR, evictionStrategy, evictionListener);
+ }
+ }
+
+ /**
+ * Creates a new, empty map with the specified maximum capacity, load factor, concurrency
+ * level and LRU eviction policy.
+ *
+ * @param capacity
+ * is the upper bound capacity for the number of elements in this map
+ *
+ * @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 BoundedConcurrentHashMap(int capacity, int concurrencyLevel)
+ {
+ this(capacity, concurrencyLevel, Eviction.LRU);
+ }
+
+ /**
+ * Creates a new, empty map with the specified maximum capacity, load factor, concurrency
+ * level and eviction strategy.
+ *
+ * @param capacity
+ * is the upper bound capacity for the number of elements in this map
+ *
+ * @param concurrencyLevel
+ * the estimated number of concurrently updating threads. The implementation performs
+ * internal sizing to try to accommodate this many threads.
+ *
+ * @param evictionStrategy
+ * the algorithm used to evict elements from this map
+ *
+ * @throws IllegalArgumentException
+ * if the initial capacity is negative or the load factor or concurrencyLevel are
+ * nonpositive.
+ */
+ public BoundedConcurrentHashMap(int capacity, int concurrencyLevel, Eviction evictionStrategy)
+ {
+ this(capacity, concurrencyLevel, evictionStrategy, new NullEvictionListener<K, V>());
+ }
+
+ /**
+ * Creates a new, empty map with the specified maximum capacity, default concurrency
+ * level and LRU eviction policy.
+ *
+ * @param capacity
+ * is the upper bound capacity for the number of elements in this map
+ *
+ *
+ * @throws IllegalArgumentException if the initial capacity of
+ * elements is negative or the load factor is nonpositive
+ *
+ * @since 1.6
+ */
+ public BoundedConcurrentHashMap(int capacity)
+ {
+ this(capacity, DEFAULT_CONCURRENCY_LEVEL);
+ }
+
+ /**
+ * Creates a new, empty map with the default maximum capacity
+ */
+ public BoundedConcurrentHashMap()
+ {
+ this(DEFAULT_MAXIMUM_CAPACITY, DEFAULT_CONCURRENCY_LEVEL);
+ }
+
+ /**
+ * Returns <tt>true</tt> if this map contains no key-value mappings.
+ *
+ * @return <tt>true</tt> if this map contains no key-value mappings
+ */
+ @Override
+ 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
+ {
+ mc[i] = segments[i].modCount;
+ mcsum += mc[i];
+ }
+ }
+ // 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
+ */
+ @Override
+ 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;
+ mc[i] = segments[i].modCount;
+ mcsum += mc[i];
+ }
+ 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.)
+ *
+ * @param key The key
+ * @return The value
+ * @throws NullPointerException if the specified key is null
+ */
+ @Override
+ public V get(Object key)
+ {
+ int hash = hash(key.hashCode());
+ 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
+ */
+ @Override
+ public boolean containsKey(Object key)
+ {
+ int hash = hash(key.hashCode());
+ 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
+ */
+ @Override
+ 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 mcsum = 0;
+ for (int i = 0; i < segments.length; ++i)
+ {
+ @SuppressWarnings("unused")
+ int c = segments[i].count; // read-volatile
+ mc[i] = segments[i].modCount;
+ mcsum += mc[i];
+ if (segments[i].containsValue(value))
+ {
+ return true;
+ }
+ }
+ boolean cleanSweep = true;
+ if (mcsum != 0)
+ {
+ for (int i = 0; i < segments.length; ++i)
+ {
+ @SuppressWarnings("unused")
+ int c = segments[i].count; // read-volatile
+ 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
+ */
+ @Override
+ public V put(K key, V value)
+ {
+ if (value == null)
+ {
+ throw new NullPointerException();
+ }
+ int hash = hash(key.hashCode());
+ 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
+ */
+ @Override
+ public V putIfAbsent(K key, V value)
+ {
+ if (value == null)
+ {
+ throw new NullPointerException();
+ }
+ int hash = hash(key.hashCode());
+ 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
+ */
+ @Override
+ 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
+ */
+ @Override
+ public V remove(Object key)
+ {
+ int hash = hash(key.hashCode());
+ return segmentFor(hash).remove(key, hash, null);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @throws NullPointerException if the specified key is null
+ */
+ @Override
+ public boolean remove(Object key, Object value)
+ {
+ int hash = hash(key.hashCode());
+ if (value == null)
+ {
+ return false;
+ }
+ return segmentFor(hash).remove(key, hash, value) != null;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @throws NullPointerException if any of the arguments are null
+ */
+ @Override
+ public boolean replace(K key, V oldValue, V newValue)
+ {
+ if (oldValue == null || newValue == null)
+ {
+ throw new NullPointerException();
+ }
+ int hash = hash(key.hashCode());
+ 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
+ */
+ @Override
+ public V replace(K key, V value)
+ {
+ if (value == null)
+ {
+ throw new NullPointerException();
+ }
+ int hash = hash(key.hashCode());
+ return segmentFor(hash).replace(key, hash, value);
+ }
+
+ /**
+ * Removes all of the mappings from this map.
+ */
+ @Override
+ public void clear()
+ {
+ for (int i = 0; i < segments.length; ++i)
+ {
+ segments[i].clear();
+ }
+ }
+
+ /**
+ * 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.
+ * @return The keys
+ */
+ @Override
+ public Set<K> keySet()
+ {
+ Set<K> ks = keySet;
+ if (ks == null)
+ {
+ keySet = new KeySet();
+ ks = keySet;
+ }
+ return ks;
+ }
+
+ /**
+ * 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.
+ * @return The values
+ */
+ @Override
+ public Collection<V> values()
+ {
+ Collection<V> vs = values;
+ if (vs == null)
+ {
+ values = new Values();
+ vs = values;
+ }
+ return vs;
+ }
+
+ /**
+ * 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.
+ * @return The entry set
+ */
+ @Override
+ public Set<Map.Entry<K, V>> entrySet()
+ {
+ Set<Map.Entry<K, V>> es = entrySet;
+ if (es == null)
+ {
+ entrySet = new EntrySet();
+ es = entrySet;
+ }
+ return es;
+ }
+
+ /**
+ * 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 -------------- */
+
+ /**
+ * Hash iterator
+ */
+ abstract class HashIterator
+ {
+ /** Next segment index */
+ int nextSegmentIndex;
+
+ /** Next table index */
+ int nextTableIndex;
+
+ /** Current table */
+ HashEntry<K, V>[] currentTable;
+
+ /** Next entry */
+ HashEntry<K, V> nextEntry;
+
+ /** Last returned */
+ HashEntry<K, V> lastReturned;
+
+ /**
+ * Constructor
+ */
+ HashIterator()
+ {
+ nextSegmentIndex = segments.length - 1;
+ nextTableIndex = -1;
+ advance();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasMoreElements()
+ {
+ return hasNext();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ final void advance()
+ {
+ if (nextEntry != null)
+ {
+ nextEntry = nextEntry.next;
+ if (nextEntry != null)
+ {
+ return;
+ }
+ }
+
+ while (nextTableIndex >= 0)
+ {
+ nextEntry = currentTable[nextTableIndex--];
+ if (nextEntry != 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)
+ {
+ nextEntry = currentTable[j];
+ if (nextEntry != null)
+ {
+ nextTableIndex = j - 1;
+ return;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public boolean hasNext()
+ {
+ return nextEntry != null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ HashEntry<K, V> nextEntry()
+ {
+ if (nextEntry == null)
+ {
+ throw new NoSuchElementException();
+ }
+ lastReturned = nextEntry;
+ advance();
+ return lastReturned;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public void remove()
+ {
+ if (lastReturned == null)
+ {
+ throw new IllegalStateException();
+ }
+ BoundedConcurrentHashMap.this.remove(lastReturned.key);
+ lastReturned = null;
+ }
+ }
+
+ /**
+ * Key iterator
+ */
+ final class KeyIterator extends HashIterator implements Iterator<K>, Enumeration<K>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public K next()
+ {
+ return super.nextEntry().key;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public K nextElement()
+ {
+ return super.nextEntry().key;
+ }
+ }
+
+ /**
+ * Value iterator
+ */
+ final class ValueIterator extends HashIterator implements Iterator<V>, Enumeration<V>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public V next()
+ {
+ return super.nextEntry().value;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public V nextElement()
+ {
+ return super.nextEntry().value;
+ }
+ }
+
+ /**
+ * Custom Entry class used by EntryIterator.next(), that relays
+ * setValue changes to the underlying map.
+ */
+ final class WriteThroughEntry extends AbstractMap.SimpleEntry<K, V>
+ {
+ private static final long serialVersionUID = -7041346694785573824L;
+
+ /**
+ * Write through
+ * @param k The key
+ * @param v The value
+ */
+ 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.
+ * @param value The value
+ * @return The value
+ */
+ @Override
+ public V setValue(V value)
+ {
+ if (value == null)
+ {
+ throw new NullPointerException();
+ }
+ V v = super.setValue(value);
+ BoundedConcurrentHashMap.this.put(getKey(), value);
+ return v;
+ }
+ }
+
+ /**
+ * Entry iterator
+ */
+ final class EntryIterator extends HashIterator implements Iterator<Entry<K, V>>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Map.Entry<K, V> next()
+ {
+ HashEntry<K, V> e = super.nextEntry();
+ return new WriteThroughEntry(e.key, e.value);
+ }
+ }
+
+ /**
+ * Key set
+ */
+ final class KeySet extends AbstractSet<K>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Iterator<K> iterator()
+ {
+ return new KeyIterator();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int size()
+ {
+ return BoundedConcurrentHashMap.this.size();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean isEmpty()
+ {
+ return BoundedConcurrentHashMap.this.isEmpty();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean contains(Object o)
+ {
+ return BoundedConcurrentHashMap.this.containsKey(o);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean remove(Object o)
+ {
+ return BoundedConcurrentHashMap.this.remove(o) != null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void clear()
+ {
+ BoundedConcurrentHashMap.this.clear();
+ }
+ }
+
+ /**
+ * Values
+ */
+ final class Values extends AbstractCollection<V>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Iterator<V> iterator()
+ {
+ return new ValueIterator();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int size()
+ {
+ return BoundedConcurrentHashMap.this.size();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean isEmpty()
+ {
+ return BoundedConcurrentHashMap.this.isEmpty();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean contains(Object o)
+ {
+ return BoundedConcurrentHashMap.this.containsValue(o);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void clear()
+ {
+ BoundedConcurrentHashMap.this.clear();
+ }
+ }
+
+ /**
+ * Entry set
+ */
+ final class EntrySet extends AbstractSet<Map.Entry<K, V>>
+ {
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Iterator<Map.Entry<K, V>> iterator()
+ {
+ return new EntryIterator();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean contains(Object o)
+ {
+ if (!(o instanceof Map.Entry))
+ {
+ return false;
+ }
+ Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+ V v = BoundedConcurrentHashMap.this.get(e.getKey());
+ return v != null && v.equals(e.getValue());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean remove(Object o)
+ {
+ if (!(o instanceof Map.Entry))
+ {
+ return false;
+ }
+ Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+ return BoundedConcurrentHashMap.this.remove(e.getKey(), e.getValue());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int size()
+ {
+ return BoundedConcurrentHashMap.this.size();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean isEmpty()
+ {
+ return BoundedConcurrentHashMap.this.isEmpty();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void clear()
+ {
+ BoundedConcurrentHashMap.this.clear();
+ }
+ }
+
+ /* ---------------- Serialization Support -------------- */
+
+ /**
+ * Save the state of the <tt>ConcurrentHashMap</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(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)
+ {
+ s.writeObject(e.key);
+ s.writeObject(e.value);
+ }
+ }
+ }
+ finally
+ {
+ seg.unlock();
+ }
+ }
+ s.writeObject(null);
+ s.writeObject(null);
+ }
+
+ /**
+ * Reconstitute the <tt>ConcurrentHashMap</tt> instance from a
+ * stream (i.e., deserialize it).
+ * @param s the stream
+ */
+ @SuppressWarnings("unchecked")
+ private void readObject(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: projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/LRUCachePolicy.java
===================================================================
--- projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/LRUCachePolicy.java 2011-05-11 19:12:01 UTC (rev 111345)
+++ projects/jboss-jca/trunk/adapters/src/main/java/org/jboss/jca/adapters/jdbc/util/LRUCachePolicy.java 2011-05-11 21:15:53 UTC (rev 111346)
@@ -1,878 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source.
- * Copyright 2008, Red Hat Middleware LLC, and individual contributors
- * as indicated by the @author tags. See the copyright.txt file 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.jca.adapters.jdbc.util;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Implementation of a Least Recently Used cache policy.
- *
- * @author <a href="mailto:stefano.maestri at redhat.com">Stefano Maestri</a>
- * @version $Revision$
- */
- at SuppressWarnings("unchecked")
-public class LRUCachePolicy
-{
- // Constants -----------------------------------------------------
-
- // Attributes ----------------------------------------------------
- /**
- * The map holding the cached objects
- */
- protected Map map;
-
- /**
- * The linked list used to implement the LRU algorithm
- */
- protected LRUList lruList;
-
- /**
- * The maximum capacity of this cache
- */
- protected int maxCapacity;
-
- /**
- * The minimum capacity of this cache
- */
- protected int minCapacity;
-
- // Static --------------------------------------------------------
-
- // Constructors --------------------------------------------------
- /**
- * Creates a LRU cache policy object with zero cache capacity.
- *
- * @see #create
- */
- public LRUCachePolicy()
- {
- }
-
- /**
- * Creates a LRU cache policy object with the specified minimum
- * and maximum capacity.
- * @param min min
- * @param max max
- *
- * @see #create
- */
- public LRUCachePolicy(int min, int max)
- {
- if (min < 2 || min > max)
- {
- throw new IllegalArgumentException("Illegal cache capacities");
- }
- minCapacity = min;
- maxCapacity = max;
- }
-
- /**
- * Create map holding entries.
- *
- * @return the map
- */
- protected Map createMap()
- {
- return new HashMap();
- }
-
- // Public --------------------------------------------------------
-
- // Service implementation ----------------------------------------------
- /**
- * Initializes the cache, creating all required objects and initializing their
- * values.
- * @see #start
- * @see #destroy
- */
- public void create()
- {
- map = createMap();
- lruList = createList();
- lruList.maxCapacity = maxCapacity;
- lruList.minCapacity = minCapacity;
- lruList.capacity = maxCapacity;
- }
-
- /**
- * Starts this cache that is now ready to be used.
- * @see #create
- * @see #stop
- */
- public void start()
- {
- }
-
- /**
- * Stops this cache thus {@link #flush}ing all cached objects. <br>
- * After this method is called, a call to {@link #start} will restart the cache.
- * @see #start
- * @see #destroy
- */
- public void stop()
- {
- if (lruList != null)
- {
- flush();
- }
- }
-
- /**
- * Destroys the cache that is now unusable. <br>
- * To have it working again it must be re-{@link #create}ed and
- * re-{@link #start}ed.
- *
- * @see #create
- */
- public void destroy()
- {
- if (map != null)
- map.clear();
- if (lruList != null)
- lruList.clear();
- }
-
- /**
- *
- * get method
- *
- * @param key key
- * @return the value
- */
- public Object get(Object key)
- {
- if (key == null)
- {
- throw new IllegalArgumentException("Requesting an object using a null key");
- }
-
- LRUCacheEntry value = (LRUCacheEntry) map.get(key);
- if (value != null)
- {
- lruList.promote(value);
- return value.object;
- }
- else
- {
- cacheMiss();
- return null;
- }
- }
-
- /**
- *
- * peek
- *
- * @param key the key
- * @return the value
- */
- public Object peek(Object key)
- {
- if (key == null)
- {
- throw new IllegalArgumentException("Requesting an object using a null key");
- }
-
- LRUCacheEntry value = (LRUCacheEntry) map.get(key);
- if (value == null)
- {
- return null;
- }
- else
- {
- return value.object;
- }
- }
-
- /**
- *
- * insert
- *
- * @param key the key
- * @param o value
- */
- public void insert(Object key, Object o)
- {
- if (o == null)
- {
- throw new IllegalArgumentException("Cannot insert a null object in the cache");
- }
- if (key == null)
- {
- throw new IllegalArgumentException("Cannot insert an object in the cache with null key");
- }
- if (map.containsKey(key))
- {
- throw new IllegalStateException("Attempt to put in the cache an object that is already there");
- }
- lruList.demote();
- LRUCacheEntry entry = createCacheEntry(key, o);
- map.put(key, entry);
- lruList.promote(entry);
- }
-
- /**
- *
- * remove
- *
- * @param key the key
- */
- public void remove(Object key)
- {
- if (key == null)
- {
- throw new IllegalArgumentException("Removing an object using a null key");
- }
-
- Object value = map.remove(key);
- if (value != null)
- {
- lruList.remove((LRUCacheEntry) value);
- }
- //else Do nothing, the object isn't in the cache list
- }
-
- /**
- *
- * flush
- *
- */
- public void flush()
- {
- LRUCacheEntry entry = null;
- while ((entry = lruList.tail) != null)
- {
- ageOut(entry);
- }
- }
-
- /**
- *
- * size
- *
- * @return the size
- */
- public int size()
- {
- return lruList.count;
- }
-
- // Y overrides ---------------------------------------------------
-
- // Package protected ---------------------------------------------
-
- // Protected -----------------------------------------------------
- /**
- * Factory method for the linked list used by this cache implementation.
- * @return the lru list
- */
- protected LRUList createList()
- {
- return new LRUList();
- }
-
- /**
- * Callback method called when the cache algorithm ages out of the cache
- * the given entry. <br>
- * The implementation here is removing the given entry from the cache.
- * @param entry entry
- */
- protected void ageOut(LRUCacheEntry entry)
- {
- remove(entry.key);
- }
-
- /**
- * Callback method called when a cache miss happens.
- */
- protected void cacheMiss()
- {
- }
-
- /**
- * Factory method for cache entries
- * @param key key
- * @param value value
- * @return the entry entry
- */
- protected LRUCacheEntry createCacheEntry(Object key, Object value)
- {
- return new LRUCacheEntry(key, value);
- }
-
- // Private -------------------------------------------------------
-
- // Inner classes -------------------------------------------------
- /**
- * Double queued list used to store cache entries.
- */
- public class LRUList
- {
- /** The maximum capacity of the cache list */
- private int maxCapacity;
-
- /** The minimum capacity of the cache list */
- private int minCapacity;
-
- /** The current capacity of the cache list */
- private int capacity;
-
- /** The number of cached objects */
- private int count;
-
- /** The head of the double linked list */
- private LRUCacheEntry head;
-
- /** The tail of the double linked list */
- private LRUCacheEntry tail;
-
- /** The cache misses happened */
- private int cacheMiss;
-
- /**
- * Creates a new double queued list.
- */
- protected LRUList()
- {
- head = null;
- tail = null;
- count = 0;
- }
-
- /**
- * Promotes the cache entry <code>entry</code> to the last used position
- * of the list. <br>
- * If the object is already there, does nothing.
- * @param entry the object to be promoted, cannot be null
- * @see #demote
- * @throws IllegalStateException if this method is called with a full cache
- */
- protected void promote(LRUCacheEntry entry)
- {
- if (entry == null)
- {
- throw new IllegalArgumentException("Trying to promote a null object");
- }
- if (capacity < 1)
- {
- throw new IllegalStateException("Can't work with capacity < 1");
- }
-
- entryPromotion(entry);
-
- entry.time = System.currentTimeMillis();
- if (entry.prev == null)
- {
- if (entry.next == null)
- {
- // entry is new or there is only the head
- if (count == 0) // cache is empty
- {
- head = entry;
- tail = entry;
- ++count;
- entryAdded(entry);
- }
- else if (count == 1 && head == entry)
- {
- // there is only the head and I want to promote it, do nothing
- }
- else if (count < capacity)
- {
- entry.prev = null;
- entry.next = head;
- head.prev = entry;
- head = entry;
- ++count;
- entryAdded(entry);
- }
- else if (count < maxCapacity)
- {
- entry.prev = null;
- entry.next = head;
- head.prev = entry;
- head = entry;
- ++count;
- int oldCapacity = capacity;
- ++capacity;
- entryAdded(entry);
- capacityChanged(oldCapacity);
- }
- else
- {
- throw new IllegalStateException("Attempt to put a new cache entry on a full cache");
- }
- }
- else
- {
- // entry is the head, do nothing
- }
- }
- else
- {
- if (entry.next == null) // entry is the tail
- {
- LRUCacheEntry beforeLast = entry.prev;
- beforeLast.next = null;
- entry.prev = null;
- entry.next = head;
- head.prev = entry;
- head = entry;
- tail = beforeLast;
- }
- else
- // entry is in the middle of the list
- {
- LRUCacheEntry previous = entry.prev;
- previous.next = entry.next;
- entry.next.prev = previous;
- entry.prev = null;
- entry.next = head;
- head.prev = entry;
- head = entry;
- }
- }
- }
-
- /**
- * Demotes from the cache the least used entry. <br>
- * If the cache is not full, does nothing.
- * @see #promote
- */
- protected void demote()
- {
- if (capacity < 1)
- {
- throw new IllegalStateException("Can't work with capacity < 1");
- }
- if (count > maxCapacity)
- {
- throw new IllegalStateException("Cache list entries number (" + count +
- ") > than the maximum allowed (" + maxCapacity + ")");
- }
- if (count == maxCapacity)
- {
- LRUCacheEntry entry = tail;
-
- // the entry will be removed by ageOut
- ageOut(entry);
- }
- else
- {
- // cache is not full, do nothing
- }
- }
-
- /**
- * Removes from the cache list the specified entry.
- * @param entry entry
- */
- protected void remove(LRUCacheEntry entry)
- {
- if (entry == null)
- {
- throw new IllegalArgumentException("Cannot remove a null entry from the cache");
- }
- if (count < 1)
- {
- throw new IllegalStateException("Trying to remove an entry from an empty cache");
- }
-
- entry.key = null;
- entry.object = null;
- if (count == 1)
- {
- head = null;
- tail = null;
- }
- else
- {
- if (entry.prev == null) // the head
- {
- head = entry.next;
- head.prev = null;
- entry.next = null;
- }
- else if (entry.next == null) // the tail
- {
- tail = entry.prev;
- tail.next = null;
- entry.prev = null;
- }
- else
- // in the middle
- {
- entry.next.prev = entry.prev;
- entry.prev.next = entry.next;
- entry.prev = null;
- entry.next = null;
- }
- }
- --count;
- entryRemoved(entry);
- }
-
- /**
- * Callback that signals that the given entry is just about to be added.
- * @param entry entry
- */
- protected void entryPromotion(LRUCacheEntry entry)
- {
- }
-
- /**
- * Callback that signals that the given entry has been added to the cache.
- * @param entry entry
- */
- protected void entryAdded(LRUCacheEntry entry)
- {
- }
-
- /**
- * Callback that signals that the given entry has been removed from the cache.
- * @param entry entry
- */
- protected void entryRemoved(LRUCacheEntry entry)
- {
- }
-
- /**
- * Callback that signals that the capacity of the cache is changed.
- * @param oldCapacity the capacity before the change happened
- */
- protected void capacityChanged(int oldCapacity)
- {
- }
-
- /**
- *
- * clear
- *
- */
- protected void clear()
- {
- LRUCacheEntry entry = head;
- head = null;
- tail = null;
- count = 0;
- for (; entry != null; entry = entry.next)
- entryRemoved(entry);
- }
-
- @Override
- public String toString()
- {
- String s = Integer.toHexString(super.hashCode());
- s += " size: " + count;
- for (LRUCacheEntry entry = head; entry != null; entry = entry.next)
- {
- s += "\n" + entry;
- }
- return s;
- }
-
- /**
- * Get the maxCapacity.
- *
- * @return the maxCapacity.
- */
- public final int getMaxCapacity()
- {
- return maxCapacity;
- }
-
- /**
- * Set the maxCapacity.
- *
- * @param maxCapacity The maxCapacity to set.
- */
- public final void setMaxCapacity(int maxCapacity)
- {
- this.maxCapacity = maxCapacity;
- }
-
- /**
- * Get the minCapacity.
- *
- * @return the minCapacity.
- */
- public final int getMinCapacity()
- {
- return minCapacity;
- }
-
- /**
- * Set the minCapacity.
- *
- * @param minCapacity The minCapacity to set.
- */
- public final void setMinCapacity(int minCapacity)
- {
- this.minCapacity = minCapacity;
- }
-
- /**
- * Get the capacity.
- *
- * @return the capacity.
- */
- public final int getCapacity()
- {
- return capacity;
- }
-
- /**
- * Set the capacity.
- *
- * @param capacity The capacity to set.
- */
- public final void setCapacity(int capacity)
- {
- this.capacity = capacity;
- }
-
- /**
- * Get the count.
- *
- * @return the count.
- */
- public final int getCount()
- {
- return count;
- }
-
- /**
- * Set the count.
- *
- * @param count The count to set.
- */
- public final void setCount(int count)
- {
- this.count = count;
- }
-
- /**
- * Get the head.
- *
- * @return the head.
- */
- public final LRUCacheEntry getHead()
- {
- return head;
- }
-
- /**
- * Set the head.
- *
- * @param head The head to set.
- */
- public final void setHead(LRUCacheEntry head)
- {
- this.head = head;
- }
-
- /**
- * Get the tail.
- *
- * @return the tail.
- */
- public final LRUCacheEntry getTail()
- {
- return tail;
- }
-
- /**
- * Set the tail.
- *
- * @param tail The tail to set.
- */
- public final void setTail(LRUCacheEntry tail)
- {
- this.tail = tail;
- }
-
- /**
- * Get the cacheMiss.
- *
- * @return the cacheMiss.
- */
- public final int getCacheMiss()
- {
- return cacheMiss;
- }
-
- /**
- * Set the cacheMiss.
- *
- * @param cacheMiss The cacheMiss to set.
- */
- public final void setCacheMiss(int cacheMiss)
- {
- this.cacheMiss = cacheMiss;
- }
- }
-
- /**
- * Double linked cell used as entry in the cache list.
- */
- public class LRUCacheEntry
- {
- /** Reference to the next cell in the list */
- private LRUCacheEntry next;
-
- /** Reference to the previous cell in the list */
- private LRUCacheEntry prev;
-
- /** The key used to retrieve the cached object */
- private Object key;
-
- /** The cached object */
- private Object object;
-
- /** The timestamp of the creation */
- private long time;
-
- /**
- * Creates a new double linked cell, storing the object we
- * want to cache and the key that is used to retrieve it.
- * @param key key
- * @param object object
- */
- protected LRUCacheEntry(Object key, Object object)
- {
- this.key = key;
- this.object = object;
- next = null;
- prev = null;
- time = 0; // Set when inserted in the list.
- }
-
- @Override
- public String toString()
- {
- return "key: " + key + ", object: " +
- (object == null ? "null" : Integer.toHexString(object.hashCode())) + ", entry: " +
- Integer.toHexString(super.hashCode());
- }
-
- /**
- * Get the next.
- *
- * @return the next.
- */
- public final LRUCacheEntry getNext()
- {
- return next;
- }
-
- /**
- * Set the next.
- *
- * @param next The next to set.
- */
- public final void setNext(LRUCacheEntry next)
- {
- this.next = next;
- }
-
- /**
- * Get the prev.
- *
- * @return the prev.
- */
- public final LRUCacheEntry getPrev()
- {
- return prev;
- }
-
- /**
- * Set the prev.
- *
- * @param prev The prev to set.
- */
- public final void setPrev(LRUCacheEntry prev)
- {
- this.prev = prev;
- }
-
- /**
- * Get the key.
- *
- * @return the key.
- */
- public final Object getKey()
- {
- return key;
- }
-
- /**
- * Set the key.
- *
- * @param key The key to set.
- */
- public final void setKey(Object key)
- {
- this.key = key;
- }
-
- /**
- * Get the object.
- *
- * @return the object.
- */
- public final Object getObject()
- {
- return object;
- }
-
- /**
- * Set the object.
- *
- * @param object The object to set.
- */
- public final void setObject(Object object)
- {
- this.object = object;
- }
-
- /**
- * Get the time.
- *
- * @return the time.
- */
- public final long getTime()
- {
- return time;
- }
-
- /**
- * Set the time.
- *
- * @param time The time to set.
- */
- public final void setTime(long time)
- {
- this.time = time;
- }
- }
-}
More information about the jboss-cvs-commits
mailing list