add module [demo-java-threadSafeCache]

Signed-off-by: ooooo <[email protected]>

Author: ooooo-youwillsee

spring-boot-annotationProcessor/build.gradle renamed to demo-java-annotationProcessor/build.gradle

@@ -5,8 +5,8 @@ dependencyManagement {
 }
 
 dependencies {
-//    annotationProcessor project(":spring-boot-annotationProcessor")
-//    testAnnotationProcessor project(":spring-boot-annotationProcessor")
+//    annotationProcessor project(":demo-java-annotationProcessor")
+//    testAnnotationProcessor project(":demo-java-annotationProcessor")
     implementation(files("${System.properties['java.home']}/../lib/tools.jar"))
 
     testImplementation('com.google.testing.compile:compile-testing:0.19')

spring-boot-annotationProcessor/src/main/java/com/ooooo/annotation/MyGetter.java renamed to demo-java-annotationProcessor/src/main/java/com/ooooo/annotation/MyGetter.java

@@ -0,0 +1,3 @@
+dependencies {
+
+}

spring-boot-annotationProcessor/src/main/java/com/ooooo/annotation/MyGetterAnnotationProcessor.java renamed to demo-java-annotationProcessor/src/main/java/com/ooooo/annotation/MyGetterAnnotationProcessor.java

@@ -0,0 +1,14 @@
+package com.ooooo.cache;
+
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="https://github.com/ooooo-youwillsee">ooooo</a>
+ * @since 1.0.0
+ */
+public interface Cache<T> {
+
+  T get(String key);
+
+  void put(String key, Supplier<T> supplier);
+}

spring-boot-annotationProcessor/src/main/resources/META-INF/services/javax.annotation.processing.Processor renamed to demo-java-annotationProcessor/src/main/resources/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1,35 @@
+package com.ooooo.cache.impl;
+
+import com.ooooo.cache.Cache;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="https://github.com/ooooo-youwillsee">ooooo</a>
+ * @since 1.0.0
+ */
+public class SafeCacheImpl1<T> implements Cache<T> {
+
+  private final Map<String, T> map = new HashMap<>();
+
+  @Override
+  public synchronized T get(String key) {
+    return map.get(key);
+  }
+
+  /**
+   * 因为使用 synchronized, 导致性能太低了
+   * 比如 A -> AValue, B -> BValue, 这两个操作应该是互不影响的，
+   * 但是现在锁是同一个，所以性能不高
+   *
+   * @param key
+   * @param supplier
+   */
+  @Override
+  public synchronized void put(String key, Supplier<T> supplier) {
+    if (!map.containsKey(key)) {
+      map.put(key, supplier.get());
+    }
+  }
+}

spring-boot-annotationProcessor/src/main/resources/User.java renamed to demo-java-annotationProcessor/src/main/resources/User.java

@@ -0,0 +1,39 @@
+package com.ooooo.cache.impl;
+
+import com.ooooo.cache.Cache;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="https://github.com/ooooo-youwillsee">ooooo</a>
+ * @since 1.0.0
+ */
+public class SafeCacheImpl2<T> implements Cache<T> {
+
+  private final Map<String, T> map = new HashMap<>();
+
+  @Override
+  public synchronized T get(String key) {
+    return map.get(key);
+  }
+
+  /**
+   * 因为使用 synchronized, 导致性能太低了
+   * 比如 A -> AValue, B -> BValue, 这两个操作应该是互不影响的，
+   * 但是现在锁是同一个，所以性能不高
+   *
+   * @param key
+   * @param supplier
+   */
+  @Override
+  public void put(String key, Supplier<T> supplier) {
+    if (!map.containsKey(key)) {
+      synchronized (this) {
+        if (!map.containsKey(key)) {
+          map.put(key, supplier.get());
+        }
+      }
+    }
+  }
+}

spring-boot-annotationProcessor/src/test/java/com/ooooo/annotation/MyGetterAnnotationProcessorTest.java renamed to demo-java-annotationProcessor/src/test/java/com/ooooo/annotation/MyGetterAnnotationProcessorTest.java

@@ -0,0 +1,34 @@
+package com.ooooo.cache.impl;
+
+import com.ooooo.cache.Cache;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="https://github.com/ooooo-youwillsee">ooooo</a>
+ * @since 1.0.0
+ */
+public class SafeCacheImpl3<T> implements Cache<T> {
+
+  private final Map<String, T> map = new ConcurrentHashMap<>();
+
+  @Override
+  public T get(String key) {
+    return map.get(key);
+  }
+
+  @Override
+  public void put(String key, Supplier<T> supplier) {
+    // 每次都会计算 supplier.get(), 导致重复计算
+    // map.putIfAbsent(key, supplier.get());
+
+    // 存在竞态条件，所有会导致 supplier.get() 会被重复计算, value 值不一样
+    // if (!map.containsKey(key)) {
+    //   map.put(key, supplier.get());
+    // }
+
+    // 最好的做法
+    map.computeIfAbsent(key, __ -> supplier.get());
+  }
+}

demo-java-threadSafeCache/build.gradle

@@ -0,0 +1,58 @@
+package com.ooooo.cache.impl;
+
+import com.ooooo.cache.Cache;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="https://github.com/ooooo-youwillsee">ooooo</a>
+ * @since 1.0.0
+ */
+public class SafeCacheImpl4<T> implements Cache<T> {
+
+  private final Map<String, ValueHolder<T>> map = new ConcurrentHashMap<>();
+
+  @Override
+  public T get(String key) {
+    return map.get(key).get();
+  }
+
+  @Override
+  public void put(String key, Supplier<T> supplier) {
+    if (map.containsKey(key)) {
+      return;
+    }
+
+    ValueHolder<T> value = new ValueHolder<>(supplier);
+    ValueHolder<T> targetValue = map.putIfAbsent(key, value);
+    if (targetValue == null) {
+      targetValue = value;
+      // 初始化调用
+      targetValue.get();
+    }
+  }
+
+  private static class ValueHolder<T> {
+
+    private final AtomicBoolean init = new AtomicBoolean(false);
+
+    private volatile T value;
+
+    private Supplier<T> supplier;
+
+    private ValueHolder(Supplier<T> supplier) {
+      this.supplier = supplier;
+    }
+
+    T get() {
+      if (init.compareAndSet(false, true)) {
+        value = supplier.get();
+        supplier = null;
+      }
+
+      return value;
+    }
+  }
+}

demo-java-threadSafeCache/src/main/java/com/ooooo/cache/Cache.java

@@ -0,0 +1,34 @@
+package com.ooooo.cache.impl;
+
+import com.ooooo.cache.Cache;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="https://github.com/ooooo-youwillsee">ooooo</a>
+ * @since 1.0.0
+ */
+public class UnsafeCacheImpl<T> implements Cache<T> {
+
+  private final Map<String, T> map = new HashMap<>();
+
+  @Override
+  public T get(String key) {
+    return map.get(key);
+  }
+
+  /**
+   * 两个线程会同时去执行 put 方法，所以线程不安全
+   *
+   * @param key
+   * @param supplier
+   */
+  @Override
+  public void put(String key, Supplier<T> supplier) {
+    if (!map.containsKey(key)) {
+      // 两个线程都会执行这里，所以线程不安全
+      map.put(key, supplier.get());
+    }
+  }
+}

demo-java-threadSafeCache/src/main/java/com/ooooo/cache/impl/SafeCacheImpl1.java

@@ -53,7 +53,9 @@ include "spring-boot-methodHandler"
 
 include "spring-boot-grpc"
 
-include "spring-boot-annotationProcessor"
+include "demo-java-annotationProcessor"
+
+include "demo-java-threadSafeCache"
 
 // spring boot examples
 include "spring-boot-examples:spring-boot-redis"