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 <sun...@apache.org>
Authored: Mon Feb 5 10:35:22 2018 +0800
Committer: sunlan <sun...@apache.org>
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();
         }

Reply via email to