eliminate AtomicLong from Generic(s) -> less memory

Author: sizovs

src/main/java/an/awesome/pipelinr/Generic.java

@@ -6,7 +6,6 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * Resolves generic types (like <C> or List<R>) into concrete runtime types in the
@@ -25,14 +24,11 @@
  */
 public abstract class Generic<C> {
 
-  private static final Map<Generic<?>, Type> RESOLVED_GENERICS = new ConcurrentHashMap<>();
+  private static Map<Generic<?>, Type> RESOLVED_GENERICS = new ConcurrentHashMap<>();
 
   private final Class<?> context;
   private final Type diamond;
 
-  // For testing
-  final AtomicLong numberOfScans = new AtomicLong();
-
   protected Generic(Class<?> context) {
     this.context = context;
     this.diamond = capture();
@@ -53,7 +49,6 @@ public Class<? super C> resolve() {
             this,
             it -> {
               Mappings mappings = new Scanner().scan(context);
-              numberOfScans.incrementAndGet();
               return mappings.get(diamond);
             });
   }
@@ -71,6 +66,11 @@ public int hashCode() {
     return 31 * context.hashCode() + diamond.hashCode();
   }
 
+  // for testing
+  static void setCache(ConcurrentHashMap<Generic<?>, Type> cache) {
+    Generic.RESOLVED_GENERICS = cache;
+  }
+
   /** Walks the class hierarchy, collecting mappings between type variables and actual types. */
   private static class Scanner {
 

src/test/java/an/awesome/pipelinr/GenericTest.java

@@ -3,7 +3,11 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.lang.reflect.Type;
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
 import org.junit.jupiter.api.Test;
 
 class GenericTest {
@@ -23,21 +27,54 @@ void throwsIfNotParameterized() {
 
   @Test
   void resolvesMultipleGenericTypes() {
+    class ConcurrentHashMapWithStats<K, V> extends ConcurrentHashMap<K, V> {
+      final AtomicInteger misses = new AtomicInteger(0);
+
+      @Override
+      public V computeIfAbsent(K key, Function<? super K, ? extends V> compute) {
+        Function<? super K, ? extends V> computeAndTrackMisses =
+            (Function<K, V>)
+                k -> {
+                  misses.incrementAndGet();
+                  return compute.apply(k);
+                };
+        return super.computeIfAbsent(key, computeAndTrackMisses);
+      }
+    }
+
+    ConcurrentHashMapWithStats<Generic<?>, Type> cache = new ConcurrentHashMapWithStats<>();
+    Generic.setCache(cache);
+
     abstract class IKnowMyType<Foo, Bar> {
-      final Generic<Foo> foo = new Generic<Foo>(getClass()) {};
-      final Generic<Bar> bar = new Generic<Bar>(getClass()) {};
+      final Generic<Foo> foo1 = new Generic<Foo>(getClass()) {};
+      final Generic<Foo> foo2 = new Generic<Foo>(getClass()) {};
+      final Generic<Bar> bar1 = new Generic<Bar>(getClass()) {};
+      final Generic<Bar> bar2 = new Generic<Bar>(getClass()) {};
     }
 
+    // no reads upon construction -> no cache misses
     IKnowMyType<String, Integer> subj = new IKnowMyType<String, Integer>() {};
+    assertThat(cache.misses).hasValue(0);
+
+    // reading the same generic instance twice -> 1 miss
+    assertThat(subj.foo1.resolve()).isEqualTo(String.class);
+    assertThat(subj.foo1.resolve()).isEqualTo(String.class);
+    assertThat(cache.misses).hasValue(1);
 
-    assertThat(subj.foo.resolve()).isEqualTo(String.class);
-    assertThat(subj.bar.resolve()).isEqualTo(Integer.class);
-    assertThat(subj.bar.resolve()).isEqualTo(Integer.class);
-    assertThat(subj.bar.resolve()).isEqualTo(Integer.class);
+    // reading the same generic, but difference instance twice -> still 1 miss
+    assertThat(subj.foo2.resolve()).isEqualTo(String.class);
+    assertThat(subj.foo2.resolve()).isEqualTo(String.class);
+    assertThat(cache.misses).hasValue(1);
 
-    // caching test
-    assertThat(subj.foo.numberOfScans).hasValue(1);
-    assertThat(subj.bar.numberOfScans).hasValue(1);
+    // reading different generic (same instance, twice) -> +1 new miss => 2 total
+    assertThat(subj.bar1.resolve()).isEqualTo(Integer.class);
+    assertThat(subj.bar1.resolve()).isEqualTo(Integer.class);
+    assertThat(cache.misses).hasValue(2);
+
+    // reading the same generic, difference instance  -> no new misses => 2 total
+    assertThat(subj.bar2.resolve()).isEqualTo(Integer.class);
+    assertThat(subj.bar2.resolve()).isEqualTo(Integer.class);
+    assertThat(cache.misses).hasValue(2);
   }
 
   @Test
@@ -48,4 +85,10 @@ abstract class IKnowMyType<T> {
     IKnowMyType<List<String>> subj = new IKnowMyType<List<String>>() {};
     assertThat(subj.foo.resolve()).isEqualTo(List.class);
   }
+
+  @Test
+  void resolvesRawTypes() {
+    Generic<String> foo = new Generic<String>(getClass()) {};
+    assertThat(foo.resolve()).isEqualTo(String.class);
+  }
 }