Repository: groovy Updated Branches: refs/heads/master c170300cd -> 2c4a9b694
Refine `ConcurrentCommonCache`: delegate to `CommonCache` instance Project: http://git-wip-us.apache.org/repos/asf/groovy/repo Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/2c4a9b69 Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/2c4a9b69 Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/2c4a9b69 Branch: refs/heads/master Commit: 2c4a9b694154d699492c2491df5e4d068d93aa26 Parents: c170300 Author: sunlan <[email protected]> Authored: Mon Feb 5 10:35:22 2018 +0800 Committer: sunlan <[email protected]> Committed: Mon Feb 5 10:35:34 2018 +0800 ---------------------------------------------------------------------- .../groovy/runtime/memoize/CommonCache.java | 17 +++--- .../runtime/memoize/ConcurrentCommonCache.java | 55 +++++++++++--------- 2 files changed, 42 insertions(+), 30 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/groovy/blob/2c4a9b69/src/main/java/org/codehaus/groovy/runtime/memoize/CommonCache.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/codehaus/groovy/runtime/memoize/CommonCache.java b/src/main/java/org/codehaus/groovy/runtime/memoize/CommonCache.java index 6012181..29f048f 100644 --- a/src/main/java/org/codehaus/groovy/runtime/memoize/CommonCache.java +++ b/src/main/java/org/codehaus/groovy/runtime/memoize/CommonCache.java @@ -19,6 +19,7 @@ package org.codehaus.groovy.runtime.memoize; +import java.io.Serializable; import java.lang.ref.SoftReference; import java.lang.ref.WeakReference; import java.util.Collection; @@ -29,15 +30,14 @@ import java.util.Map; import java.util.Set; /** - * * Represents a simple key-value cache, which is NOT thread safe and backed by a {@link java.util.Map} instance * * @param <K> type of the keys * @param <V> type of the values - * * @since 2.5.0 */ -public class CommonCache<K, V> implements EvictableCache<K, V> { +public class CommonCache<K, V> implements EvictableCache<K, V>, Serializable { + private static final long serialVersionUID = 934699400232698324L; /** * The default load factor */ @@ -46,6 +46,7 @@ public class CommonCache<K, V> implements EvictableCache<K, V> { * The default initial capacity */ public static final int DEFAULT_INITIAL_CAPACITY = 16; + private final Map<K, V> map; /** @@ -57,8 +58,9 @@ public class CommonCache<K, V> implements EvictableCache<K, V> { /** * Constructs a cache with limited size - * @param initialCapacity initial capacity of the cache - * @param maxSize max size of the cache + * + * @param initialCapacity initial capacity of the cache + * @param maxSize max size of the cache * @param evictionStrategy LRU or FIFO, see {@link org.codehaus.groovy.runtime.memoize.EvictableCache.EvictionStrategy} */ public CommonCache(final int initialCapacity, final int maxSize, final EvictionStrategy evictionStrategy) { @@ -75,8 +77,9 @@ public class CommonCache<K, V> implements EvictableCache<K, V> { /** * Constructs a LRU cache with the specified initial capacity and max size. * The LRU cache is slower than {@link LRUCache} + * * @param initialCapacity initial capacity of the LRU cache - * @param maxSize max size of the LRU cache + * @param maxSize max size of the LRU cache */ public CommonCache(int initialCapacity, int maxSize) { this(initialCapacity, maxSize, EvictionStrategy.LRU); @@ -84,6 +87,7 @@ public class CommonCache<K, V> implements EvictableCache<K, V> { /** * Constructs a LRU cache with the default initial capacity + * * @param maxSize max size of the LRU cache * @see #CommonCache(int, int) */ @@ -93,6 +97,7 @@ public class CommonCache<K, V> implements EvictableCache<K, V> { /** * Constructs a cache backed by the specified {@link java.util.Map} instance + * * @param map the {@link java.util.Map} instance */ public CommonCache(Map<K, V> map) { http://git-wip-us.apache.org/repos/asf/groovy/blob/2c4a9b69/src/main/java/org/codehaus/groovy/runtime/memoize/ConcurrentCommonCache.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/codehaus/groovy/runtime/memoize/ConcurrentCommonCache.java b/src/main/java/org/codehaus/groovy/runtime/memoize/ConcurrentCommonCache.java index 24ae6c3..8e090a9 100644 --- a/src/main/java/org/codehaus/groovy/runtime/memoize/ConcurrentCommonCache.java +++ b/src/main/java/org/codehaus/groovy/runtime/memoize/ConcurrentCommonCache.java @@ -18,65 +18,73 @@ */ package org.codehaus.groovy.runtime.memoize; +import java.io.Serializable; import java.util.Collection; import java.util.Map; import java.util.Set; import java.util.concurrent.locks.ReentrantReadWriteLock; /** - * * Represents a simple key-value cache, which is thread safe and backed by a {@link java.util.Map} instance * * @param <K> type of the keys * @param <V> type of the values - * * @since 2.5.0 */ -public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { +public class ConcurrentCommonCache<K, V> implements EvictableCache<K, V>, Serializable { + private static final long serialVersionUID = -7352338549333024936L; + private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); private final ReentrantReadWriteLock.ReadLock readLock = rwl.readLock(); private final ReentrantReadWriteLock.WriteLock writeLock = rwl.writeLock(); + private final CommonCache<K, V> commonCache; /** * Constructs a cache with unlimited size */ - public ConcurrentCommonCache() {} + public ConcurrentCommonCache() { + commonCache = new CommonCache<K, V>(); + } /** * Constructs a cache with limited size - * @param initialCapacity initial capacity of the cache - * @param maxSize max size of the cache + * + * @param initialCapacity initial capacity of the cache + * @param maxSize max size of the cache * @param evictionStrategy LRU or FIFO, see {@link org.codehaus.groovy.runtime.memoize.EvictableCache.EvictionStrategy} */ public ConcurrentCommonCache(int initialCapacity, int maxSize, EvictionStrategy evictionStrategy) { - super(initialCapacity, maxSize, evictionStrategy); + commonCache = new CommonCache<K, V>(initialCapacity, maxSize, evictionStrategy); } /** * Constructs a LRU cache with the specified initial capacity and max size. * The LRU cache is slower than {@link LRUCache} + * * @param initialCapacity initial capacity of the LRU cache - * @param maxSize max size of the LRU cache + * @param maxSize max size of the LRU cache */ public ConcurrentCommonCache(int initialCapacity, int maxSize) { - super(initialCapacity, maxSize); + commonCache = new CommonCache<K, V>(initialCapacity, maxSize); } /** * Constructs a LRU cache with the default initial capacity(16) + * * @param maxSize max size of the LRU cache * @see #ConcurrentCommonCache(int, int) */ public ConcurrentCommonCache(int maxSize) { - super(maxSize); + commonCache = new CommonCache<K, V>(maxSize); } /** * Constructs a cache backed by the specified {@link java.util.Map} instance + * * @param map the {@link java.util.Map} instance */ public ConcurrentCommonCache(Map<K, V> map) { - super(map); + commonCache = new CommonCache<K, V>(map); } /** @@ -86,7 +94,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public V get(K key) { readLock.lock(); try { - return super.get(key); + return commonCache.get(key); } finally { readLock.unlock(); } @@ -99,7 +107,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public V put(K key, V value) { writeLock.lock(); try { - return super.put(key, value); + return commonCache.put(key, value); } finally { writeLock.unlock(); } @@ -113,13 +121,12 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { return getAndPut(key, valueProvider, true); } - @Override public V getAndPut(K key, ValueProvider<? super K, ? extends V> valueProvider, boolean shouldCache) { V value; readLock.lock(); try { - value = super.get(key); + value = commonCache.get(key); if (null != value) { return value; } @@ -130,14 +137,14 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { writeLock.lock(); try { // try to find the cached value again - value = super.get(key); + value = commonCache.get(key); if (null != value) { return value; } value = null == valueProvider ? null : valueProvider.provide(key); if (shouldCache && null != value) { - super.put(key, value); + commonCache.put(key, value); } } finally { writeLock.unlock(); @@ -153,7 +160,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public Collection<V> values() { readLock.lock(); try { - return super.values(); + return commonCache.values(); } finally { readLock.unlock(); } @@ -166,7 +173,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public Set<K> keys() { readLock.lock(); try { - return super.keys(); + return commonCache.keys(); } finally { readLock.unlock(); } @@ -179,7 +186,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public boolean containsKey(K key) { readLock.lock(); try { - return super.containsKey(key); + return commonCache.containsKey(key); } finally { readLock.unlock(); } @@ -192,7 +199,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public int size() { readLock.lock(); try { - return super.size(); + return commonCache.size(); } finally { readLock.unlock(); } @@ -205,7 +212,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public V remove(K key) { writeLock.lock(); try { - return super.remove(key); + return commonCache.remove(key); } finally { writeLock.unlock(); } @@ -218,7 +225,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public Map<K, V> clear() { writeLock.lock(); try { - return super.clear(); + return commonCache.clear(); } finally { writeLock.unlock(); } @@ -231,7 +238,7 @@ public class ConcurrentCommonCache<K, V> extends CommonCache<K, V> { public void cleanUpNullReferences() { writeLock.lock(); try { - super.cleanUpNullReferences(); + commonCache.cleanUpNullReferences(); } finally { writeLock.unlock(); }
