Single threaded cache

Author: IzzelAliz

src/main/java/io/izzel/mesmerize/impl/service/SimpleStatsService.java

@@ -3,6 +3,7 @@
 import com.github.benmanes.caffeine.cache.CacheLoader;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.Scheduler;
 import io.izzel.mesmerize.api.cause.CauseManager;
 import io.izzel.mesmerize.api.event.DamageCalculator;
 import io.izzel.mesmerize.api.event.StatsRefreshEvent;
@@ -29,12 +30,17 @@
 import org.bukkit.entity.Entity;
 import org.bukkit.persistence.PersistentDataContainer;
 import org.bukkit.persistence.PersistentDataType;
+import org.checkerframework.checker.index.qual.Positive;
+import org.checkerframework.checker.nullness.qual.NonNull;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collections;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
 import java.util.concurrent.TimeUnit;
 
 public class SimpleStatsService implements StatsService {
@@ -45,32 +51,34 @@ public class SimpleStatsService implements StatsService {
     private final ElementFactory elementFactory = new SimpleElementFactory();
     private final DamageCalculator calculator = new SimpleCalculator();
 
-    private final Set<Integer> entityLock = Collections.newSetFromMap(new ConcurrentHashMap<>());
-
     private final CacheLoader<Entity, StatsSet> cacheLoader = entity -> {
-        Callable<StatsSet> callable = () -> {
-            if (!entity.isValid() || entity.isDead()) {
-                return null;
-            }
+        if (!entity.isValid() || entity.isDead()) {
+            return null;
+        }
+        if (Bukkit.isPrimaryThread()) {
             StatsSet statsSet = new StatsSet();
             newEntityReader(entity).accept(statsSet, VisitMode.VALUE);
             Bukkit.getPluginManager().callEvent(new StatsRefreshEvent(entity, statsSet));
             return statsSet;
-        };
-        if (Bukkit.isPrimaryThread()) {
-            return callable.call();
         } else {
-            try {
-                entityLock.add(entity.getEntityId());
-                return Bukkit.getScheduler().callSyncMethod(Mesmerize.instance(), callable).get();
-            } finally {
-                entityLock.remove(entity.getEntityId());
-            }
+            throw new IllegalStateException("async stats load");
         }
     };
 
     private final LoadingCache<Entity, StatsSet> statsSetCache = Caffeine
         .newBuilder()
+        .scheduler((executor, command, delay, unit) -> {
+            FutureTask<?> task = new FutureTask<>(command, null);
+            Bukkit.getScheduler().runTaskLater(Mesmerize.instance(), () -> executor.execute(task), unit.toMillis(delay) / 50);
+            return task;
+        })
+        .executor(r -> {
+            if (Bukkit.isPrimaryThread()) {
+                r.run();
+            } else {
+                throw new IllegalStateException("async stats load");
+            }
+        })
         .refreshAfterWrite(ConfigSpec.spec().performance().entityStatsCacheMs(), TimeUnit.MILLISECONDS)
         .build(cacheLoader);
 
@@ -91,20 +99,7 @@ public CauseManager getCauseManager() {
 
     @Override
     public StatsSet cachedSetFor(@NotNull Entity entity) {
-        if (!Bukkit.isPrimaryThread()) {
-            throw new IllegalStateException("async stats get");
-        }
-        StatsSet set;
-        if (entityLock.contains(entity.getEntityId())) {
-            try {
-                set = cacheLoader.load(entity);
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        } else {
-            set = statsSetCache.get(entity);
-        }
-        return set == null ? new StatsSet() : set;
+        return statsSetCache.get(entity);
     }
 
     @Override