.Enty getdata(@NotNull K key) throws Exception {
+ // 缓存记录对象
+ final var enty = new Enty();
+
+ // get ref
+ LOCK.read(() -> {
+ enty.ref = map.get(key);
+ // 获取内容
+ if ( enty.ref == null )
+ enty.val = null;
+ else
+ enty.val = enty.ref.get();
+ });
+
+ /* 检查获取的数据 */
+ if ( enty.val == null ) {
+ var b = true;
+ /* 自旋，直到数据完整 */
+ while( b ){
+ b = LOCK.write(() -> {
+ /* 当前是否正在释放 */
+ if ( (enty.ref = map.get(key)) == null || (enty.val = enty.ref.get()) == null ) {
+ /* 扫尾接口是否运行完成 */
+ if ( cleanableMap.get(key) == null ) {
+ // 空数据处理
+ enty.val = emptyData(key);
+ enty.ref = map.get(key);
+
+ // 被彻底释放，完整的空数据
+ return false;
+ }
+ // 数据不完整，继续等待
+ return true;
+ } else
+ // 数据完整
+ return false;
+ });
+ }
+ }
+ return enty;
+ }
+
+ /**
+ * 无数据时的数据
+ *
+ * @return 在没有缓存时返回的数据
+ */
+ @Nullable
+ protected abstract
+ V emptyData(@NotNull K key) throws Exception;
+
+ /**
+ * 更新缓存内容
+ *
+ * @param key 缓存键
+ * @param v 缓存内容
+ */
+ protected
+ void putdata(@NotNull K key, @NotNull V v) throws Exception {
+ final var enty = new Enty();
+
+ /* 检查获取的数据 */
+ var b = true;
+ /* 自旋，直到数据完整 */
+ while( b ){
+ b = LOCK.write(() -> {
+ /* 正在释放 */
+ if ( ((enty.ref = map.get(key)) != null && (enty.val = enty.ref.get()) == null) && cleanableMap.get(key) != null )
+ // 等待释放完成
+ return true;
+
+ /* 获取对象的回收方法 */
+ Runnable clean;
+ if ( v instanceof CanClean )
+ clean = ((CanClean) v).getclean();
+ else
+ clean = null;
+
+ /* 注册回收方法 */
+ cleanableMap.put(key, CacheGcThrea.binClean(v, () -> LOCK.write(() -> {
+ if ( clean != null )
+ clean.run();
+ cleanableMap.remove(key);
+ map.remove(key);
+ }, null, null)));
+
+ // 放入缓存
+ map.put(key, refClass.getConstructor(Object.class).newInstance(v));
+ // 处理完成
+ return false;
+ });
+ }
+ }
+
+ /**
+ * 移除缓存
+ *
+ * 强制释放缓存内容
+ * 将缓存内容主动加入回收队列
+ *
+ * @param key 要释放的键
+ *
+ * @return 释放的内容
+ */
+ @Nullable
+ protected
+ V removeData(@NotNull K key) {
+ final var cac = new Object() {
+ Reference ref;
+ V v;
+ };
+
+ return LOCK.write(() -> {
+ // 已在释放
+ if ( (cac.ref = map.get(key)) == null || (cac.v = cac.ref.get()) == null )
+ return null;
+
+ // 手动释放
+ cac.ref.enqueue();
+ return cac.v;
+ }, null, null);
+ }
+
+ /** 清空缓存数据 */
+ public
+ void clear() {
+ // 释放
+ LOCK.write(() -> {
+ map.values().forEach(v -> {
+ // 对象被释放
+ if ( v == null || v.get() == null )
+ return;
+ v.enqueue();
+ });
+ map.clear();
+ }, null, null);
+ }
+
+ /**
+ * {@link MapCacheOb} 子类通用构造工具.
+ *
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since MapCacheOb 0.0.1
+ */
+ @SuppressWarnings("unchecked")
+ public static abstract
+ class Build> {
/** 缓存引用类型 */
- protected final Class> refClass;
- /** 数据缓存区 */
- protected final Map> map = new HashMap<>();
-
- /** 回收接口存放区 */
- protected final Map cleanableMap = new HashMap<>();
-
+ protected Class refernce = SoftReference.class;
/** 并发管理 */
- protected final SyLock LOCK;
-
- //----------------------------------------------------------------------------------------------
+ protected SyLock lockBy = SyLock.newRWLock();
- /** 构造缓存，指定缓存方式 */
- public
- MapCacheOb(@NotNull Class refc) { this(refc, SyLock.newRWLock()); }
-
- /** 构造缓存，指定缓存方式和并发管理 */
+ /** 设置缓存引用类型 */
+ @NotNull
public
- MapCacheOb(@NotNull Class refc, @NotNull SyLock syLock) {
- refClass = (Class>) refc;
- LOCK = syLock;
+ B refernce(Class refernce) {
+ this.refernce = refernce;
+ return (B) this;
}
- //----------------------------------------------------------------------------------------------
-
- /**
- * 获取缓存数据
- *
- * @param key 缓存的键
- *
- * @return 缓存记录对象
- *
- * @see Enty
- */
+ /** 设置并发管理 */
@NotNull
- protected
- MapCacheOb.Enty getdata(@NotNull K key) throws Exception {
- // 缓存记录对象
- final var enty = new Enty();
-
- // get ref
- LOCK.read(() -> {
- enty.ref = map.get(key);
- // 获取内容
- if (enty.ref == null)
- enty.val = null;
- else
- enty.val = enty.ref.get();
- });
-
- /* 检查获取的数据 */
- if (enty.val == null) {
- var b = true;
- /* 自旋，直到数据完整 */
- while( b ){
- b = LOCK.trywrite(Exception.class, () -> {
- /* 当前是否正在释放 */
- if ((enty.ref = map.get(key)) == null || (enty.val = enty.ref.get()) == null) {
- /* 扫尾接口是否运行完成 */
- if (cleanableMap.get(key) == null) {
- // 空数据处理
- enty.val = emptyData(key);
- enty.ref = map.get(key);
-
- // 被彻底释放，完整的空数据
- return false;
- }
- // 数据不完整，继续等待
- return true;
- } else
- // 数据完整
- return false;
- });
- }
- }
- return enty;
- }
-
- /**
- * 无数据时的数据
- *
- * @return 在没有缓存时返回的数据
- */
- @Nullable
- protected abstract
- V emptyData(@NotNull K key) throws Exception;
-
- //----------------------------------------------------------------------------------------------
-
- /**
- * 更新缓存内容
- *
- * @param key 缓存键
- * @param v 缓存内容
- */
- protected
- void putdata(@NotNull K key, @NotNull V v) throws Exception {
- final var enty = new Enty();
-
- /* 检查获取的数据 */
- var b = true;
- /* 自旋，直到数据完整 */
- while( b ){
- b = LOCK.trywrite(Exception.class, () -> {
- /* 正在释放 */
- if (((enty.ref = map.get(key)) != null && (enty.val = enty.ref.get()) == null) &&
- cleanableMap.get(key) != null)
- // 等待释放完成
- return true;
-
- /* 获取对象的回收方法 */
- Runnable clean;
- if (v instanceof CanClean)
- clean = ((CanClean) v).getclean();
- else
- clean = null;
-
- /* 注册回收方法 */
- cleanableMap.put(key, CacheGcThrea.binClean(v, () -> LOCK.write(() -> {
- if (clean != null)
- clean.run();
- cleanableMap.remove(key);
- map.remove(key);
- })));
-
- // 放入缓存
- map.put(key, refClass.getConstructor(Object.class).newInstance(v));
- // 处理完成
- return false;
- });
- }
- }
-
- /**
- * 移除缓存
- *
- * 强制释放缓存内容
- * 将缓存内容主动加入回收队列
- *
- * @param key 要释放的键
- *
- * @return 释放的内容
- */
- @Nullable
- protected
- V removeData(@NotNull K key) {
- final var cac = new Object() {
- Reference ref;
- V v;
- };
-
- return LOCK.write(() -> {
- // 已在释放
- if ((cac.ref = map.get(key)) == null || (cac.v = cac.ref.get()) == null)
- return null;
-
- // 手动释放
- cac.ref.enqueue();
- return cac.v;
- });
- }
-
- /** 清空缓存数据 */
public
- void clear() {
- // 释放
- LOCK.write(() -> {
- map.values().forEach(v -> {
- // 对象被释放
- if (v == null || v.get() == null)
- return;
- v.enqueue();
- });
- map.clear();
- });
- }
-
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * {@link MapCacheOb} 子类通用构造工具.
- *
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @version 0.0.1
- * @since MapCacheOb 0.0.1
- */
- @SuppressWarnings( "unchecked" )
- public static abstract
- class Build> {
- /** 缓存引用类型 */
- protected Class refernce = SoftReference.class;
- /** 并发管理 */
- protected SyLock lockBy = SyLock.newRWLock();
-
- /** 设置缓存引用类型 */
- @NotNull
- public
- B refernce(Class refernce) {
- this.refernce = refernce;
- return (B) this;
- }
-
- /** 设置并发管理 */
- @NotNull
- public
- B lockBy(@NotNull SyLock lockBy) {
- this.lockBy = lockBy;
- return (B) this;
- }
-
- @NotNull
- public abstract
- MapCacheOb build();
+ B lockBy(@NotNull SyLock lockBy) {
+ this.lockBy = lockBy;
+ return (B) this;
}
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * 缓存记录类.
- * 记录缓存的引用对象 {@link #ref}
- * 记录缓存的内容 {@link #val}
- *
- * @author fybug
- * @version 0.0.1
- * @since MapCacheOb 0.0.1
- */
- protected final
- class Enty {
- public volatile Reference ref;
- public volatile V val;
- }
+ @NotNull
+ public abstract
+ MapCacheOb build();
+ }
+
+ /**
+ * 缓存记录类.
+ * 记录缓存的引用对象 {@link #ref}
+ * 记录缓存的内容 {@link #val}
+ *
+ * @author fybug
+ * @version 0.0.1
+ * @since MapCacheOb 0.0.1
+ */
+ protected final
+ class Enty {
+ public volatile Reference ref;
+ public volatile V val;
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/MemoryCache.java b/src/main/java/fybug/nulll/pdcache/MemoryCache.java
index 6d12c1cff87ecafb8f070979b21667eef4e34966..9a82380af2e26d4c52c47041f445784c9d4009fd 100644
--- a/src/main/java/fybug/nulll/pdcache/MemoryCache.java
+++ b/src/main/java/fybug/nulll/pdcache/MemoryCache.java
@@ -1,11 +1,10 @@
package fybug.nulll.pdcache;
-import org.jetbrains.annotations.NotNull;
-
import java.io.Closeable;
import java.lang.ref.Reference;
import fybug.nulll.pdconcurrent.SyLock;
import fybug.nulll.pdconcurrent.fun.tryConsumer;
+import jakarta.validation.constraints.NotNull;
/**
* 作用于内存中的数据缓存.
@@ -19,46 +18,42 @@ import fybug.nulll.pdconcurrent.fun.tryConsumer;
public abstract
class MemoryCache extends CacheOb implements Closeable {
- /** 构造缓存，指定缓存方式 */
- protected
- MemoryCache(@NotNull Class refc) { super(refc); }
-
- /** 构造缓存，指定缓存方式和并发管理 */
- protected
- MemoryCache(@NotNull Class refc, @NotNull SyLock syLock)
- { super(refc, syLock); }
-
- //----------------------------------------------------------------------------------------------
-
- /**
- * 使用缓存的内容运行
- *
- * 可以避免没有给予缓存对象强引用而导致缓存丢失的情况
- *
- * @param run 使用缓存的回调
- *
- * @return V
- *
- * @see #get()
- */
- public
- V get(@NotNull tryConsumer run) throws Exception {
- var i = get();
- run.accept(i);
- return i;
- }
-
- /**
- * 获取缓存数据
- *
- * @return 缓存数据
- */
- public
- V get() throws Exception { return getdata(); }
-
- //----------------------------------------------------------------------------------------------
-
- @Override
- public
- void close() { clear(); }
+ /** 构造缓存，指定缓存方式 */
+ protected
+ MemoryCache(@NotNull Class refc) { super(refc); }
+
+ /** 构造缓存，指定缓存方式和并发管理 */
+ protected
+ MemoryCache(@NotNull Class refc, @NotNull SyLock syLock)
+ { super(refc, syLock); }
+
+ /**
+ * 使用缓存的内容运行
+ *
+ * 可以避免没有给予缓存对象强引用而导致缓存丢失的情况
+ *
+ * @param run 使用缓存的回调
+ *
+ * @return V
+ *
+ * @see #get()
+ */
+ public
+ V get(@NotNull tryConsumer run) throws Exception {
+ var i = get();
+ run.accept(i);
+ return i;
+ }
+
+ /**
+ * 获取缓存数据
+ *
+ * @return 缓存数据
+ */
+ public
+ V get() throws Exception { return getdata(); }
+
+ @Override
+ public
+ void close() { clear(); }
}
diff --git a/src/main/java/fybug/nulll/pdcache/MemoryMapCache.java b/src/main/java/fybug/nulll/pdcache/MemoryMapCache.java
index 2ab1d2bea32198daf5f87393f4962f34324312a6..644ee9c6fe821d19909751b5bf89b65f4ab2b5a1 100644
--- a/src/main/java/fybug/nulll/pdcache/MemoryMapCache.java
+++ b/src/main/java/fybug/nulll/pdcache/MemoryMapCache.java
@@ -1,12 +1,11 @@
package fybug.nulll.pdcache;
-import org.jetbrains.annotations.NotNull;
-
import java.io.Closeable;
import java.lang.ref.Reference;
+import java.util.function.BiConsumer;
import fybug.nulll.pdcache.err.CacheError;
import fybug.nulll.pdconcurrent.SyLock;
-import fybug.nulll.pdconcurrent.fun.tryBiConsumer;
+import jakarta.validation.constraints.NotNull;
import lombok.Getter;
/**
@@ -22,73 +21,66 @@ import lombok.Getter;
*/
public abstract
class MemoryMapCache extends MapCacheOb implements Closeable {
- public
- MemoryMapCache(@NotNull Class refc) { super(refc); }
-
- public
- MemoryMapCache(@NotNull Class refc, @NotNull SyLock syLock)
- { super(refc, syLock); }
-
- //----------------------------------------------------------------------------------------------
-
- /**
- * 获取缓存数据
- *
- * @param key 缓存的键
- *
- * @return 缓存数据
- */
- public
- V get(@NotNull K key) throws Exception, CacheError {
- if (isClose())
- throw new CacheError();
- return getdata(key).val;
- }
+ public
+ MemoryMapCache(@NotNull Class refc) { super(refc); }
- /**
- * 使用缓存的内容运行
- *
- * 可以避免没有给予缓存对象强引用而导致缓存丢失的情况
- *
- * @param key 缓存的键
- * @param run 使用缓存的回调，传入 param key 和 {@link #get(K)}
- *
- * @return 缓存数据
- *
- * @see #get(K)
- */
- public
- V get(@NotNull K key, @NotNull tryBiConsumer run) throws Exception, CacheError
- {
- var cache = get(key);
- run.accept(key, cache);
- return cache;
- }
+ public
+ MemoryMapCache(@NotNull Class refc, @NotNull SyLock syLock)
+ { super(refc, syLock); }
- //----------------------------------------------------------------------------------------------
+ /**
+ * 获取缓存数据
+ *
+ * @param key 缓存的键
+ *
+ * @return 缓存数据
+ */
+ public
+ V get(@NotNull K key) throws Exception, CacheError {
+ if ( isClose() )
+ throw new CacheError();
+ return getdata(key).val;
+ }
- /**
- * 移除缓存
- *
- * 强制释放缓存内容
- * 将缓存内容主动加入回收队列
- *
- * @param key 要释放的键
- */
- public
- void remove(@NotNull K key) { removeData(key); }
+ /**
+ * 使用缓存的内容运行
+ *
+ * 可以避免没有给予缓存对象强引用而导致缓存丢失的情况
+ *
+ * @param key 缓存的键
+ * @param run 使用缓存的回调，传入 param key 和 {@link #get(K)}
+ *
+ * @return 缓存数据
+ *
+ * @see #get(K)
+ */
+ public
+ V get(@NotNull K key, @NotNull BiConsumer run) throws Exception, CacheError {
+ var cache = get(key);
+ run.accept(key, cache);
+ return cache;
+ }
- //----------------------------------------------------------------------------------------------
+ /**
+ * 移除缓存
+ *
+ * 强制释放缓存内容
+ * 将缓存内容主动加入回收队列
+ *
+ * @param key 要释放的键
+ */
+ public
+ void remove(@NotNull K key) { removeData(key); }
- // 是否被关闭
- @Getter private volatile boolean isClose = false;
+ // 是否被关闭
+ @Getter private volatile boolean isClose = false;
- @Override
- public
- void close() {
- if (isClose())
- return;
- isClose = true;
- clear();
- }
+ @Override
+ public
+ void close() {
+ if ( isClose() )
+ return;
+ isClose = true;
+ clear();
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/PDCache.java b/src/main/java/fybug/nulll/pdcache/PDCache.java
index ddcfac58525a1d33eefc4b1f81e23b175b1fa894..6e7af5a895413ae5c997c343240254cabb184c9b 100644
--- a/src/main/java/fybug/nulll/pdcache/PDCache.java
+++ b/src/main/java/fybug/nulll/pdcache/PDCache.java
@@ -1,11 +1,10 @@
package fybug.nulll.pdcache;
-import org.jetbrains.annotations.NotNull;
-
import fybug.nulll.pdcache.memory.Cache;
import fybug.nulll.pdcache.memory.MapCache;
import fybug.nulll.pdcache.memory.TimeMapCache;
import fybug.nulll.pdcache.supplier.SCache;
import fybug.nulll.pdcache.supplier.SMapCache;
+import jakarta.validation.constraints.NotNull;
import lombok.experimental.UtilityClass;
/**
@@ -20,75 +19,75 @@ import lombok.experimental.UtilityClass;
@UtilityClass
public
class PDCache {
- /**
- * 缓存在内存中的单个数据缓存
- *
- * @param vClass 数据类型
- *
- * @return CacheBuild
- *
- * @see Cache
- */
- @NotNull
- public
- Cache.Build Cache(Class vClass) { return Cache.build(vClass); }
+ /**
+ * 缓存在内存中的单个数据缓存
+ *
+ * @param vClass 数据类型
+ *
+ * @return CacheBuild
+ *
+ * @see Cache
+ */
+ @NotNull
+ public
+ Cache.Build Cache(Class vClass) { return Cache.build(vClass); }
- /**
- * 缓存在内存中的自填充单个数据缓存
- *
- * @param vClass 数据类型
- *
- * @return SCacheBuild
- *
- * @see SCache
- */
- @NotNull
- public
- SCache.Build SCache(Class vClass) { return SCache.build(vClass); }
+ /**
+ * 缓存在内存中的自填充单个数据缓存
+ *
+ * @param vClass 数据类型
+ *
+ * @return SCacheBuild
+ *
+ * @see SCache
+ */
+ @NotNull
+ public
+ SCache.Build SCache(Class vClass) { return SCache.build(vClass); }
- /**
- * 缓存在内存中的映射数据缓存
- *
- * @param kClass 键的类型
- * @param vClass 数据类型
- *
- * @return MapCacheBuild
- *
- * @see MapCache
- */
- @NotNull
- public
- MapCache.Build MapCache(Class kClass, Class vClass)
- { return MapCache.build(kClass, vClass); }
+ /**
+ * 缓存在内存中的映射数据缓存
+ *
+ * @param kClass 键的类型
+ * @param vClass 数据类型
+ *
+ * @return MapCacheBuild
+ *
+ * @see MapCache
+ */
+ @NotNull
+ public
+ MapCache.Build MapCache(Class kClass, Class vClass)
+ { return MapCache.build(kClass, vClass); }
- /**
- * 缓存在内存中的自填充映射数据缓存
- *
- * @param kClass 键的类型
- * @param vClass 数据类型
- *
- * @return SMapCacheBuild
- *
- * @see SMapCache
- */
- @NotNull
- public
- SMapCache.Build SMapCache(Class kClass, Class vClass)
- { return SMapCache.build(kClass, vClass); }
+ /**
+ * 缓存在内存中的自填充映射数据缓存
+ *
+ * @param kClass 键的类型
+ * @param vClass 数据类型
+ *
+ * @return SMapCacheBuild
+ *
+ * @see SMapCache
+ */
+ @NotNull
+ public
+ SMapCache.Build SMapCache(Class kClass, Class vClass)
+ { return SMapCache.build(kClass, vClass); }
- /**
- * 缓存在内存中依靠时间管理的映射数据缓存
- *
- * @param kClass 键的类型
- * @param vClass 数据类型
- *
- * @return TimeMapCache
- *
- * @see TimeMapCache
- * @since PDCache 0.0.2
- */
- @NotNull
- public
- TimeMapCache.Build TimeMapCache(Class kClass, Class vClass)
- { return TimeMapCache.build(kClass, vClass); }
+ /**
+ * 缓存在内存中依靠时间管理的映射数据缓存
+ *
+ * @param kClass 键的类型
+ * @param vClass 数据类型
+ *
+ * @return TimeMapCache
+ *
+ * @see TimeMapCache
+ * @since PDCache 0.0.2
+ */
+ @NotNull
+ public
+ TimeMapCache.Build TimeMapCache(Class kClass, Class vClass)
+ { return TimeMapCache.build(kClass, vClass); }
}
diff --git a/src/main/java/fybug/nulll/pdcache/err/CacheError.java b/src/main/java/fybug/nulll/pdcache/err/CacheError.java
index f1131da5d9297bb77b3a940eda8f30a8a0c7e448..ffcb4e2ec5ac8ea13cf46625d356163b8be39bb3 100644
--- a/src/main/java/fybug/nulll/pdcache/err/CacheError.java
+++ b/src/main/java/fybug/nulll/pdcache/err/CacheError.java
@@ -7,4 +7,4 @@ package fybug.nulll.pdcache.err;
* @version 0.0.1
*/
public
-class CacheError extends Exception {}
+class CacheError extends RuntimeException {}
diff --git a/src/main/java/fybug/nulll/pdcache/memory/Cache.java b/src/main/java/fybug/nulll/pdcache/memory/Cache.java
index 81ca9c7b50d689c734a662529a4fef60e37e3125..e691ce6321d94301c62caf3659785d21dd8186f8 100644
--- a/src/main/java/fybug/nulll/pdcache/memory/Cache.java
+++ b/src/main/java/fybug/nulll/pdcache/memory/Cache.java
@@ -1,13 +1,12 @@
package fybug.nulll.pdcache.memory;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
import java.lang.ref.Reference;
import fybug.nulll.pdcache.CacheOb;
import fybug.nulll.pdcache.MemoryCache;
import fybug.nulll.pdconcurrent.SyLock;
import fybug.nulll.pdconcurrent.fun.tryConsumer;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
/**
* 数据缓存工具.
@@ -63,76 +62,70 @@ import fybug.nulll.pdconcurrent.fun.tryConsumer;
public
class Cache extends MemoryCache {
- /** 构造缓存，指定缓存方式 */
- public
- Cache(@NotNull Class refc) {super(refc); }
+ /** 构造缓存，指定缓存方式 */
+ public
+ Cache(@NotNull Class refc) { super(refc); }
- /** 构造缓存，指定缓存方式和并发管理 */
- public
- Cache(@NotNull Class refc, @NotNull SyLock syLock) { super(refc, syLock); }
+ /** 构造缓存，指定缓存方式和并发管理 */
+ public
+ Cache(@NotNull Class refc, @NotNull SyLock syLock) { super(refc, syLock); }
- //----------------------------------------------------------------------------------------------
+ @Nullable
+ @Override
+ public
+ V get(@NotNull tryConsumer run) throws Exception
+ { return super.get(run); }
- @Nullable
- @Override
- public
- V get(@NotNull tryConsumer<@Nullable V, Exception> run) throws Exception
- { return super.get(run); }
+ @Nullable
+ @Override
+ public
+ V get() throws Exception { return super.get(); }
- @Nullable
- @Override
- public
- V get() throws Exception { return super.get(); }
+ @Override
+ protected @Nullable
+ V emptyData()
+ { return null; }
- @Override
- protected @Nullable
- V emptyData()
- { return null; }
+ /**
+ * 放入新的缓存
+ *
+ * @param v 缓存的数据
+ *
+ * @return this
+ */
+ @NotNull
+ public
+ Cache set(@NotNull V v) throws Exception {
+ putdata(v);
+ return this;
+ }
- //-----------------------------------
+ /**
+ * 获取缓存构造工具
+ *
+ * @param 缓存内容的类型
+ *
+ * @return 构造工具
+ */
+ @NotNull
+ public static
+ Build build(Class vc) { return new Build<>(); }
- /**
- * 放入新的缓存
- *
- * @param v 缓存的数据
- *
- * @return this
- */
+ /**
+ * {@link Cache} 构造工具.
+ *
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since Cache 0.0.1
+ */
+ public final static
+ class Build extends CacheOb.Build> {
@NotNull
public
- Cache set(@NotNull V v) throws Exception {
- putdata(v);
- return this;
- }
-
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * 获取缓存构造工具
- *
- * @param 缓存内容的类型
- *
- * @return 构造工具
- */
- @NotNull
- public static
- Build build(Class vc) {return new Build<>();}
-
- /**
- * {@link Cache} 构造工具.
- *
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @version 0.0.1
- * @since Cache 0.0.1
- */
- public final static
- class Build extends CacheOb.Build> {
- @NotNull
- public
- Cache build() { return new Cache<>(refernce, lockBy); }
- }
+ Cache build() { return new Cache<>(refernce, lockBy); }
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/memory/MapCache.java b/src/main/java/fybug/nulll/pdcache/memory/MapCache.java
index c80cbcb99ce661f50e636b1a1ed606174b98da45..423d9757c075f9a5bed4618532ecb1767fa505dc 100644
--- a/src/main/java/fybug/nulll/pdcache/memory/MapCache.java
+++ b/src/main/java/fybug/nulll/pdcache/memory/MapCache.java
@@ -1,14 +1,13 @@
package fybug.nulll.pdcache.memory;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
import java.lang.ref.Reference;
+import java.util.function.BiConsumer;
import fybug.nulll.pdcache.MapCacheOb;
import fybug.nulll.pdcache.MemoryMapCache;
import fybug.nulll.pdcache.err.CacheError;
import fybug.nulll.pdconcurrent.SyLock;
-import fybug.nulll.pdconcurrent.fun.tryBiConsumer;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
/**
* 映射缓存.
@@ -66,87 +65,81 @@ import fybug.nulll.pdconcurrent.fun.tryBiConsumer;
public
class MapCache extends MemoryMapCache {
- /** 构造缓存，指定缓存方式 */
- public
- MapCache(@NotNull Class refc) { super(refc); }
+ /** 构造缓存，指定缓存方式 */
+ public
+ MapCache(@NotNull Class refc) { super(refc); }
- /** 构造缓存，指定缓存方式和并发管理 */
- public
- MapCache(@NotNull Class refc, @NotNull SyLock syLock)
- { super(refc, syLock); }
+ /** 构造缓存，指定缓存方式和并发管理 */
+ public
+ MapCache(@NotNull Class refc, @NotNull SyLock syLock)
+ { super(refc, syLock); }
- //----------------------------------------------------------------------------------------------
+ /**
+ * 获取缓存数据
+ *
+ * @param key 缓存的键
+ *
+ * @return 缓存数据
+ */
+ @Override
+ @Nullable
+ public
+ V get(@NotNull K key) throws Exception, CacheError { return super.get(key); }
- /**
- * 获取缓存数据
- *
- * @param key 缓存的键
- *
- * @return 缓存数据
- */
- @Override
- @Nullable
- public
- V get(@NotNull K key) throws Exception, CacheError { return super.get(key); }
+ @Override
+ @Nullable
+ public
+ V get(@NotNull K key, @NotNull BiConsumer run) throws Exception, CacheError
+ { return super.get(key, run); }
- @Override
- @Nullable
- public
- V get(@NotNull K key, @NotNull tryBiConsumer run) throws Exception, CacheError
- { return super.get(key, run); }
+ /**
+ * 放入新的缓存
+ *
+ * @param key 缓存的键
+ * @param val 缓存的数据
+ *
+ * @return this
+ */
+ @NotNull
+ public
+ MapCache put(@NotNull K key, @NotNull V val) throws Exception, CacheError {
+ if ( isClose() )
+ throw new CacheError();
+ putdata(key, val);
+ return this;
+ }
- //--------------------------------
+ @Nullable
+ protected
+ V emptyData(@NotNull K key) { return null; }
- /**
- * 放入新的缓存
- *
- * @param key 缓存的键
- * @param val 缓存的数据
- *
- * @return this
- */
- @NotNull
- public
- MapCache put(@NotNull K key, @NotNull V val) throws Exception, CacheError {
- if (isClose())
- throw new CacheError();
- putdata(key, val);
- return this;
- }
-
- @Nullable
- protected
- V emptyData(@NotNull K key) { return null; }
-
- /*--------------------------------------------------------------------------------------------*/
+ /**
+ * 获取缓存构造工具
+ *
+ * @param 键的类型
+ * @param 缓存内容的类型
+ *
+ * @return 构造工具
+ */
+ @NotNull
+ public static
+ Build build(Class kc, Class vc) { return new Build<>(); }
- /**
- * 获取缓存构造工具
- *
- * @param 键的类型
- * @param 缓存内容的类型
- *
- * @return 构造工具
- */
+ /**
+ * {@link MapCache} 构造工具.
+ *
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since MapCache 0.0.1
+ */
+ public static final
+ class Build extends MapCacheOb.Build> {
@NotNull
- public static
- Build build(Class kc, Class vc) {return new Build<>();}
-
- /**
- * {@link MapCache} 构造工具.
- *
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @version 0.0.1
- * @since MapCache 0.0.1
- */
- public static final
- class Build extends MapCacheOb.Build> {
- @NotNull
- public
- MapCache build() { return new MapCache<>(refernce, lockBy); }
- }
+ public
+ MapCache build() { return new MapCache<>(refernce, lockBy); }
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/memory/TimeMapCache.java b/src/main/java/fybug/nulll/pdcache/memory/TimeMapCache.java
index 5e289747907ad9bf6817a1f6056d51cfdad8b18e..38e3a9c7a4e1387ae397ef507fb1db84d36b21c6 100644
--- a/src/main/java/fybug/nulll/pdcache/memory/TimeMapCache.java
+++ b/src/main/java/fybug/nulll/pdcache/memory/TimeMapCache.java
@@ -1,7 +1,4 @@
package fybug.nulll.pdcache.memory;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
@@ -12,8 +9,11 @@ import java.util.concurrent.Executors;
import java.util.function.Consumer;
import java.util.function.Supplier;
-import fybug.nulll.pdconcurrent.ObjLock;
import fybug.nulll.pdconcurrent.SyLock;
+import fybug.nulll.pdconcurrent.fun.trySupplier;
+import fybug.nulll.pdconcurrent.lock.ObjLock;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NonNull;
@@ -50,378 +50,367 @@ import lombok.val;
*/
public
class TimeMapCache {
- /** 数据缓存区 */
- protected final Map> map = new LinkedHashMap<>();
- /** 并发管理 */
- protected final SyLock LOCK;
-
- /** 数据过期时间（毫秒） */
- @Setter protected volatile long dataTime;
-
- /** 定时器 */
- @Nullable protected final Timer timerRun;
- /** 从尾部扫描的数量 */
- @Setter protected volatile int scarrenNum;
-
- /**
- * 回收事件执行线程池
- *
- * @since 0.0.2
- */
- @NonNull
- @Setter
- @Getter
- protected ExecutorService GcThread = Executors.newCachedThreadPool();
-
- //----------------------------------------------------------------------------------------------
-
- /** 构造缓存，使用默认参数 */
- public
- TimeMapCache() { this(SyLock.newObjLock()); }
-
- /** 构造缓存，指定并发管理 */
- public
- TimeMapCache(@NotNull SyLock syLock) { this(syLock, 24 * 60 * 60000); }
-
- /** 构造缓存，指定并发管理和默认过期时间 */
- public
- TimeMapCache(@NotNull SyLock syLock, long datatime) { this(syLock, datatime, 5 * 60000); }
-
- /**
- * 构造缓存，指定参数
- *
- * @param syLock 并发管理
- * @param datatime 默认数据过期时间
- * @param scarrentime 检查线程扫描间隔，为 0 则不运行线程检查
- */
+ /** 数据缓存区 */
+ protected final Map> map = new LinkedHashMap<>();
+ /** 并发管理 */
+ protected final SyLock LOCK;
+
+ /** 数据过期时间（毫秒） */
+ @Setter protected volatile long dataTime;
+
+ /** 定时器 */
+ @Nullable protected final Timer timerRun;
+ /** 从尾部扫描的数量 */
+ @Setter protected volatile int scarrenNum;
+
+ /**
+ * 回收事件执行线程池
+ *
+ * @since 0.0.2
+ */
+ @NonNull @Setter @Getter protected ExecutorService GcThread = Executors.newCachedThreadPool();
+
+ /** 构造缓存，使用默认参数 */
+ public
+ TimeMapCache() { this(SyLock.newObjLock()); }
+
+ /** 构造缓存，指定并发管理 */
+ public
+ TimeMapCache(@NotNull SyLock syLock) { this(syLock, 24 * 60 * 60000); }
+
+ /** 构造缓存，指定并发管理和默认过期时间 */
+ public
+ TimeMapCache(@NotNull SyLock syLock, long datatime) { this(syLock, datatime, 5 * 60000); }
+
+ /**
+ * 构造缓存，指定参数
+ *
+ * @param syLock 并发管理
+ * @param datatime 默认数据过期时间
+ * @param scarrentime 检查线程扫描间隔，为 0 则不运行线程检查
+ */
+ public
+ TimeMapCache(@NotNull SyLock syLock, long datatime, long scarrentime) {
+ LOCK = syLock;
+ dataTime = datatime;
+ scarrenNum = 20;
+
+ // 是否运行线程检查
+ if ( scarrentime > 0 ) {
+ timerRun = new Timer();
+ timerRun.schedule(new TimeTask(), 0, scarrentime);
+ } else
+ timerRun = null;
+ }
+
+ /**
+ * 缓存检查任务
+ *
+ * @author fybug
+ * @version 0.0.2
+ * @since TimeMapCache 0.0.1
+ */
+ protected final
+ class TimeTask extends TimerTask {
+ @Override
public
- TimeMapCache(@NotNull SyLock syLock, long datatime, long scarrentime) {
- LOCK = syLock;
- dataTime = datatime;
- scarrenNum = 20;
-
- // 是否运行线程检查
- if (scarrentime > 0) {
- timerRun = new Timer();
- timerRun.schedule(new TimeTask(), 0, scarrentime);
- } else
- timerRun = null;
- }
-
- /**
- * 缓存检查任务
- *
- * @author fybug
- * @version 0.0.2
- * @since TimeMapCache 0.0.1
- */
- protected final
- class TimeTask extends TimerTask {
- @Override
- public
- void run() {
- LOCK.write(() -> {
- var now = System.currentTimeMillis();
- var i = 0;
- var iter = map.entrySet().iterator();
- // 检查
- while( iter.hasNext() && i++ < scarrenNum )
- CheckVal(iter, now);
- });
- }
+ void run() {
+ LOCK.write(() -> {
+ var now = System.currentTimeMillis();
+ var i = 0;
+ var iter = map.entrySet().iterator();
+ // 检查
+ while( iter.hasNext() && i++ < scarrenNum )
+ CheckVal(iter, now);
+ }, null, null);
}
-
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * 放入数据
- *
- * @param k 数据的键
- * @param v 数据内容
- *
- * @see #putData(Object, Object, long)
- */
- public
- void putData(@NotNull K k, V v) { this.putData(k, v, dataTime); }
-
- /**
- * 放入数据
- *
- * @param k 数据的键
- * @param v 数据内容
- * @param datatime 数据的过期时间，相对于当前
- */
- public
- void putData(@NotNull K k, @Nullable V v, long datatime)
- { putData(k, v, datatime, null); }
-
- /**
- * 放入数据
- *
- * @param k 数据的键
- * @param v 数据内容
- * @param datatime 数据的过期时间，相对于当前
- * @param endrun 数据被回收事件回调，接口传入当前数据，为空则不触发
- *
- * @since 0.0.2
- */
- public
- void putData(@NotNull K k, @Nullable V v, long datatime, @Nullable Consumer endrun)
- { LOCK.write(() -> map.put(k, new Enty<>(System.currentTimeMillis() + datatime, v, endrun))); }
-
- //-------------------------------------
-
- /**
- * 移除数据
- *
- * @param k 数据的键
- */
- public
- void removeData(@NotNull K k) { LOCK.write(() -> GcVal(map.remove(k))); }
-
- /**
- * 清除所有数据
- *
- * 不会触发回收事件
- */
- public
- void clear() { LOCK.write(map::clear); }
-
- //-------------------------------------
-
- /**
- * 使用数据
- *
- * 使用读锁进行
- *
- * @param k 数据的键
- *
- * @return 返回之前保存的数据，如果数据过期返回 null
- *
- * @see #getData(Object, long)
- */
- @Nullable
- public
- V getData(@NotNull K k) { return getData(k, 0); }
-
- /**
- * 使用数据
- *
- * 如果刷新时间为 0，则使用 {@link SyLock#read(Supplier)} 读锁进行
- * 如果需要刷新数据存活时间，则使用 {@link SyLock#write(Supplier)} 写锁进行
- *
- * @param k 数据的键
- * @param newDatatime 数据的新存活时间，从现在开始记录
- *
- * @return 返回之前保存的数据，如果数据过期返回 null
- *
- * @since TimeMapCache v0.0.3
- */
- @Nullable
- public
- V getData(@NotNull K k, long newDatatime) {
- // 运行函数
- Supplier r = () -> {
- if (check(k)) {
- var v = map.remove(k);
-
- // 刷新时间
- if (newDatatime > 0)
- v.setMaxtime(System.currentTimeMillis() + newDatatime);
-
- map.put(k, v);
- return v.val;
- }
- GcVal(map.remove(k));
- return null;
- };
-
- // 刷新时间用写锁，不刷新用读锁
- if (newDatatime <= 0)
- return LOCK.read(r);
- else
- return LOCK.write(r);
+ }
+
+ /**
+ * 放入数据
+ *
+ * @param k 数据的键
+ * @param v 数据内容
+ *
+ * @see #putData(Object, Object, long)
+ */
+ public
+ void putData(@NotNull K k, V v) { this.putData(k, v, dataTime); }
+
+ /**
+ * 放入数据
+ *
+ * @param k 数据的键
+ * @param v 数据内容
+ * @param datatime 数据的过期时间，相对于当前
+ */
+ public
+ void putData(@NotNull K k, @Nullable V v, long datatime)
+ { putData(k, v, datatime, null); }
+
+ /**
+ * 放入数据
+ *
+ * @param k 数据的键
+ * @param v 数据内容
+ * @param datatime 数据的过期时间，相对于当前
+ * @param endrun 数据被回收事件回调，接口传入当前数据，为空则不触发
+ *
+ * @since 0.0.2
+ */
+ public
+ void putData(@NotNull K k, @Nullable V v, long datatime, @Nullable Consumer endrun) {
+ LOCK.write(() -> {
+ map.put(k, new Enty<>(System.currentTimeMillis() + datatime, v, endrun));
+ }, null, null);
+ }
+
+ /**
+ * 移除数据
+ *
+ * @param k 数据的键
+ */
+ public
+ void removeData(@NotNull K k) { LOCK.write(() -> GcVal(map.remove(k)), null, null); }
+
+ /**
+ * 清除所有数据
+ *
+ * 不会触发回收事件
+ */
+ public
+ void clear() { LOCK.write(map::clear, null, null); }
+
+ /**
+ * 使用数据
+ *
+ * 使用读锁进行
+ *
+ * @param k 数据的键
+ *
+ * @return 返回之前保存的数据，如果数据过期返回 null
+ *
+ * @see #getData(Object, long)
+ */
+ @Nullable
+ public
+ V getData(@NotNull K k) { return getData(k, 0); }
+
+ /**
+ * 使用数据
+ *
+ * 如果刷新时间为 0，则使用 {@link SyLock#read(Supplier)} 读锁进行
+ * 如果需要刷新数据存活时间，则使用 {@link SyLock#write(Supplier)} 写锁进行
+ *
+ * @param k 数据的键
+ * @param newDatatime 数据的新存活时间，从现在开始记录
+ *
+ * @return 返回之前保存的数据，如果数据过期返回 null
+ *
+ * @since TimeMapCache v0.0.3
+ */
+ @Nullable
+ public
+ V getData(@NotNull K k, long newDatatime) {
+ // 运行函数
+ trySupplier r = () -> {
+ if ( check(k) ) {
+ var v = map.remove(k);
+
+ // 刷新时间
+ if ( newDatatime > 0 )
+ v.setMaxtime(System.currentTimeMillis() + newDatatime);
+
+ map.put(k, v);
+ return v.val;
+ }
+ GcVal(map.remove(k));
+ return null;
+ };
+
+ // 刷新时间用写锁，不刷新用读锁
+ if ( newDatatime <= 0 )
+ return LOCK.read(r, null, null);
+ else
+ return LOCK.write(r, null, null);
+ }
+
+ /**
+ * 检查数据是否可用
+ *
+ * @param k 数据的键
+ *
+ * @return 可用为 true
+ */
+ public
+ boolean checkData(@NotNull K k) {
+ return LOCK.read(() -> {
+ return check(k);
+ }, null, null);
+ }
+
+ /** 检查数据是否可用 */
+ protected
+ boolean check(@NotNull K k)
+ { return map.getOrDefault(k, new Enty<>(0, null, null)).maxtime > System.currentTimeMillis(); }
+
+ /**
+ * 获取数据剩余的存活时间
+ *
+ * @param k 数据的键
+ *
+ * @return 剩余时间（毫秒），过期为 0
+ */
+ public
+ long dataHasTime(@NotNull K k) {
+ return LOCK.read(() -> {
+ return Math.max(map.getOrDefault(k, new Enty<>(0, null, null)).maxtime - System.currentTimeMillis(), 0);
+ }, null, null);
+ }
+
+ /**
+ * 统一检查并移除过期数据
+ *
+ * 通过占用锁并扫描全部数据来彻底剔除已经过期的数据，时间点以函数开始运行的时间点为准。
+ */
+ public
+ void trimData() {
+ LOCK.write(() -> {
+ long nowtime = System.currentTimeMillis();
+ var iter = map.entrySet().iterator();
+ // 检查
+ while( iter.hasNext() )
+ CheckVal(iter, nowtime);
+ }, null, null);
+ }
+
+ /** 关闭检查线程 */
+ public
+ void closeTimeTask() {
+ if ( timerRun != null )
+ timerRun.cancel();
+ }
+
+ /**
+ * 关闭检查线程并清除数据
+ *
+ * @see #closeTimeTask()
+ * @see #clear()
+ */
+ public
+ void closeTimeTaskAndClear() {
+ closeTimeTask();
+ clear();
+ getGcThread().shutdown();
+ }
+
+ /**
+ * 检查并移除已经过期的数据
+ *
+ * @since 0.0.2
+ */
+ private
+ void CheckVal(Iterator>> iter, long nowtime) {
+ // 当前节点
+ var v = iter.next();
+ var val = v.getValue();
+ // 检查是否最大时间
+ if ( val.maxtime <= nowtime ) {
+ // 移除
+ iter.remove();
+ // 异步执行回收事件
+ GcVal(val);
}
-
- /**
- * 检查数据是否可用
- *
- * @param k 数据的键
- *
- * @return 可用为 true
- */
- public
- boolean checkData(@NotNull K k) { return LOCK.read(() -> check(k)); }
-
- /** 检查数据是否可用 */
- protected
- boolean check(@NotNull K k)
- { return map.getOrDefault(k, new Enty<>(0, null, null)).maxtime > System.currentTimeMillis(); }
-
- //-------------------------------------
-
- /**
- * 获取数据剩余的存活时间
- *
- * @param k 数据的键
- *
- * @return 剩余时间（毫秒），过期为 0
- */
+ }
+
+ /**
+ * 申请执行当前数据的回收事件
+ *
+ * @since 0.0.2
+ */
+ private
+ void GcVal(Enty v) {
+ if ( v == null )
+ return;
+ // 当前回收事件
+ val endrun = v.getEndrun();
+ // 线程池执行
+ getGcThread().submit(() -> {
+ if ( endrun != null )
+ endrun.accept(v.getVal());
+ });
+ }
+
+ /**
+ * 获取缓存构造工具
+ *
+ * @param 键的类型
+ * @param 缓存内容的类型
+ *
+ * @return 构造工具
+ */
+ @NotNull
+ public static
+ Build build(Class kClass, Class vClass) { return new Build<>(); }
+
+ /**
+ * {@link TimeMapCache} 构造工具.
+ *
+ * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
+ * - 使用 {@link #dataTime(long)} 指定数据存活时间
+ * - 使用 {@link #scarrentime(long)} 指定扫描间隔时间
+ * - 使用 {@link #scarrenNum(int)} 指定扫描数量
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since TimeMapCache 0.0.1
+ */
+ @Accessors(chain = true, fluent = true)
+ public static final
+ class Build {
+ /** 并发工具 */
+ @Setter protected SyLock lockBy = new ObjLock();
+ /** 默认数据存活时间 */
+ @Setter protected long dataTime = 5 * 60000;
+ /** 扫描时检查的数量 */
+ @Setter protected int scarrenNum = 20;
+ /** 扫描间隔时间 */
+ @Setter protected long scarrentime = 24 * 60 * 600000;
+
+ /** 构造 */
+ @NotNull
public
- long dataHasTime(@NotNull K k) {
- return LOCK.read(() -> Math.max(map.getOrDefault(k, new Enty<>(0, null, null)).maxtime -
- System.currentTimeMillis(), 0));
+ TimeMapCache build() {
+ var c = new TimeMapCache(lockBy, dataTime, scarrentime);
+ c.setScarrenNum(scarrenNum);
+ return c;
}
-
+ }
+
+ /**
+ * 数据记录对象.
+ *
+ * @author fybug
+ * @version 0.0.2
+ * @since TimeMapCache 0.0.1
+ */
+ @AllArgsConstructor
+ @Setter
+ @Getter
+ public static
+ class Enty {
+ /** 过期的时间 */
+ public long maxtime;
+ /** 数据 */
+ @Nullable public V val;
/**
- * 统一检查并移除过期数据
+ * 回收时的处理
*
- * 通过占用锁并扫描全部数据来彻底剔除已经过期的数据，时间点以函数开始运行的时间点为准。
- */
- public
- void trimData() {
- LOCK.write(() -> {
- long nowtime = System.currentTimeMillis();
- var iter = map.entrySet().iterator();
- // 检查
- while( iter.hasNext() )
- CheckVal(iter, nowtime);
- });
- }
-
- /** 关闭检查线程 */
- public
- void closeTimeTask() {
- if (timerRun != null)
- timerRun.cancel();
- }
-
- /**
- * 关闭检查线程并清除数据
- *
- * @see #closeTimeTask()
- * @see #clear()
- */
- public
- void closeTimeTaskAndClear() {
- closeTimeTask();
- clear();
- getGcThread().shutdown();
- }
-
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * 检查并移除已经过期的数据
- *
- * @since 0.0.2
- */
- private
- void CheckVal(Iterator>> iter, long nowtime) {
- // 当前节点
- var v = iter.next();
- var val = v.getValue();
- // 检查是否最大时间
- if (val.maxtime <= nowtime) {
- // 移除
- iter.remove();
- // 异步执行回收事件
- GcVal(val);
- }
- }
-
- /**
- * 申请执行当前数据的回收事件
+ * 接口传入当前数据
*
* @since 0.0.2
*/
- private
- void GcVal(Enty v) {
- if (v == null)
- return;
- // 当前回收事件
- val endrun = v.getEndrun();
- // 线程池执行
- getGcThread().submit(() -> {
- if (endrun != null)
- endrun.accept(v.getVal());
- });
- }
-
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * 获取缓存构造工具
- *
- * @param 键的类型
- * @param 缓存内容的类型
- *
- * @return 构造工具
- */
- @NotNull
- public static
- Build build(Class kClass, Class vClass) { return new Build<>(); }
-
- /**
- * {@link TimeMapCache} 构造工具.
- *
- * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
- * - 使用 {@link #dataTime(long)} 指定数据存活时间
- * - 使用 {@link #scarrentime(long)} 指定扫描间隔时间
- * - 使用 {@link #scarrenNum(int)} 指定扫描数量
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @version 0.0.1
- * @since TimeMapCache 0.0.1
- */
- @Accessors( chain = true, fluent = true )
- public static final
- class Build {
- /** 并发工具 */
- @Setter protected SyLock lockBy = new ObjLock();
- /** 默认数据存活时间 */
- @Setter protected long dataTime = 5 * 60000;
- /** 扫描时检查的数量 */
- @Setter protected int scarrenNum = 20;
- /** 扫描间隔时间 */
- @Setter protected long scarrentime = 24 * 60 * 600000;
-
- /** 构造 */
- @NotNull
- public
- TimeMapCache build() {
- var c = new TimeMapCache(lockBy, dataTime, scarrentime);
- c.setScarrenNum(scarrenNum);
- return c;
- }
- }
-
- //----------------------------------------------------------------------------------------------
-
- /**
- * 数据记录对象.
- *
- * @author fybug
- * @version 0.0.2
- * @since TimeMapCache 0.0.1
- */
- @AllArgsConstructor
- @Setter
- @Getter
- public static
- class Enty {
- /** 过期的时间 */
- public long maxtime;
- /** 数据 */
- @Nullable public V val;
- /**
- * 回收时的处理
- *
- * 接口传入当前数据
- *
- * @since 0.0.2
- */
- @Nullable public Consumer endrun;
- }
+ @Nullable public Consumer endrun;
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/supplier/LockCache.java b/src/main/java/fybug/nulll/pdcache/supplier/LockCache.java
index f4b6801979563b4b5fb101ba06a89b9c87d2a32b..4f7951d1238cc54048c5f1cdc78ad51141866ee1 100644
--- a/src/main/java/fybug/nulll/pdcache/supplier/LockCache.java
+++ b/src/main/java/fybug/nulll/pdcache/supplier/LockCache.java
@@ -1,12 +1,11 @@
package fybug.nulll.pdcache.supplier;
-import org.jetbrains.annotations.NotNull;
-
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.util.function.Supplier;
-import fybug.nulll.pdconcurrent.ObjLock;
import fybug.nulll.pdconcurrent.SyLock;
+import fybug.nulll.pdconcurrent.lock.ObjLock;
+import jakarta.validation.constraints.NotNull;
import lombok.Setter;
import lombok.experimental.Accessors;
@@ -24,88 +23,82 @@ import lombok.experimental.Accessors;
*/
public
class LockCache extends SCache {
- /** 缓存的锁的生成方法 */
- private final Supplier LOCK_SUPP;
+ /** 缓存的锁的生成方法 */
+ private final Supplier LOCK_SUPP;
- /**
- * 构造缓存，指定缓存方式和缓存的锁类型
- *
- * @see #LockCache(Class, Supplier)
- */
- public
- LockCache(@NotNull Class refc, @NotNull Class Locktype) {
- this(refc, new SyLockSupp(Locktype));
- }
+ /**
+ * 构造缓存，指定缓存方式和缓存的锁类型
+ *
+ * @see #LockCache(Class, Supplier)
+ */
+ public
+ LockCache(@NotNull Class refc, @NotNull Class Locktype) {
+ this(refc, new SyLockSupp(Locktype));
+ }
- /** 构造缓存，指定缓存方式和缓存的锁的生成方法 */
- public
- LockCache(@NotNull Class refc, @NotNull Supplier lockSupplier) {
- super(refc, SyLock.newObjLock());
- LOCK_SUPP = lockSupplier;
- }
+ /** 构造缓存，指定缓存方式和缓存的锁的生成方法 */
+ public
+ LockCache(@NotNull Class refc, @NotNull Supplier lockSupplier) {
+ super(refc, SyLock.newObjLock());
+ LOCK_SUPP = lockSupplier;
+ }
- /*--------------------------------------------------------------------------------------------*/
+ @NotNull
+ @Override
+ protected
+ SyLock createData() { return LOCK_SUPP.get(); }
- @NotNull
- @Override
- protected
- SyLock createData() { return LOCK_SUPP.get(); }
+ /**
+ * 获取构造工具
+ *
+ * @return 构造工具
+ */
+ public static
+ Build build() { return new Build(); }
- /*--------------------------------------------------------------------------------------------*/
+ /**
+ * {@link LockCache} 构造工具.
+ *
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #sylock(Class)} 绑定缓存的锁的类型
+ * - 使用 {@link #sylock(Supplier)} 绑定缓存的锁的生成方法
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since LockCache 0.0.1
+ */
+ @Accessors(chain = true, fluent = true)
+ public final static
+ class Build {
+ /** 缓存引用类型 */
+ @Setter private Class refernce = SoftReference.class;
+ /** 缓存的锁的生成方法 */
+ private Supplier sylock = ObjLock::new;
/**
- * 获取构造工具
+ * 设置缓存的锁类型
*
- * @return 构造工具
+ * @see #sylock(Supplier)
*/
- public static
- Build build() { return new Build(); }
+ @NotNull
+ public
+ Build sylock(Class sylock) { return sylock(new SyLockSupp(sylock)); }
+
+ /** 设置缓存的锁的生成方法 */
+ public
+ Build sylock(@NotNull Supplier syLockSupplier) {
+ this.sylock = syLockSupplier;
+ return this;
+ }
/**
- * {@link LockCache} 构造工具.
- *
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #sylock(Class)} 绑定缓存的锁的类型
- * - 使用 {@link #sylock(Supplier)} 绑定缓存的锁的生成方法
- * - 使用 {@link #build()} 进行构造
- *
+ * 构造锁缓存
*
- * @version 0.0.1
- * @since LockCache 0.0.1
+ * @return 锁缓存工具
*/
- @Accessors( chain = true, fluent = true )
- public final static
- class Build {
- /** 缓存引用类型 */
- @Setter private Class refernce = SoftReference.class;
- /** 缓存的锁的生成方法 */
- private Supplier sylock = ObjLock::new;
-
- //------------------------------------------------------------------------------------------
-
- /**
- * 设置缓存的锁类型
- *
- * @see #sylock(Supplier)
- */
- @NotNull
- public
- Build sylock(Class sylock) { return sylock(new SyLockSupp(sylock)); }
-
- /** 设置缓存的锁的生成方法 */
- public
- Build sylock(@NotNull Supplier syLockSupplier) {
- this.sylock = syLockSupplier;
- return this;
- }
-
- /**
- * 构造锁缓存
- *
- * @return 锁缓存工具
- */
- @NotNull
- public
- LockCache build() { return new LockCache(refernce, sylock); }
- }
+ @NotNull
+ public
+ LockCache build() { return new LockCache(refernce, sylock); }
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/supplier/LockMapCache.java b/src/main/java/fybug/nulll/pdcache/supplier/LockMapCache.java
index 3b1c76b60edfc2d138ac781faa42733a412b5182..46ba885e3776aa68f228ccdcea1fe078262a58c9 100644
--- a/src/main/java/fybug/nulll/pdcache/supplier/LockMapCache.java
+++ b/src/main/java/fybug/nulll/pdcache/supplier/LockMapCache.java
@@ -1,12 +1,11 @@
package fybug.nulll.pdcache.supplier;
-import org.jetbrains.annotations.NotNull;
-
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.util.function.Supplier;
-import fybug.nulll.pdconcurrent.ObjLock;
import fybug.nulll.pdconcurrent.SyLock;
+import fybug.nulll.pdconcurrent.lock.ObjLock;
+import jakarta.validation.constraints.NotNull;
import lombok.Setter;
import lombok.experimental.Accessors;
@@ -26,93 +25,87 @@ import lombok.experimental.Accessors;
*/
public
class LockMapCache extends SMapCache {
- /** 缓存的锁的生成方法 */
- private final Supplier LOCK_SUPP;
+ /** 缓存的锁的生成方法 */
+ private final Supplier LOCK_SUPP;
- /**
- * 构造缓存，指定缓存方式和缓存的锁类型
- *
- * @see #LockMapCache(Class, Supplier)
- */
- public
- LockMapCache(@NotNull Class refc, @NotNull Class syLock)
- { this(refc, new SyLockSupp(syLock)); }
+ /**
+ * 构造缓存，指定缓存方式和缓存的锁类型
+ *
+ * @see #LockMapCache(Class, Supplier)
+ */
+ public
+ LockMapCache(@NotNull Class refc, @NotNull Class syLock)
+ { this(refc, new SyLockSupp(syLock)); }
- /** 构造缓存，指定缓存方式和缓存的锁的生成方法 */
- public
- LockMapCache(@NotNull Class refc, @NotNull Supplier syLockSupplier)
- {
- super(refc, SyLock.newObjLock());
- LOCK_SUPP = syLockSupplier;
- }
+ /** 构造缓存，指定缓存方式和缓存的锁的生成方法 */
+ public
+ LockMapCache(@NotNull Class refc, @NotNull Supplier syLockSupplier)
+ {
+ super(refc, SyLock.newObjLock());
+ LOCK_SUPP = syLockSupplier;
+ }
- /*--------------------------------------------------------------------------------------------*/
+ @NotNull
+ @Override
+ protected
+ SyLock createData(@NotNull K key) { return LOCK_SUPP.get(); }
- @NotNull
- @Override
- protected
- SyLock createData(@NotNull K key) { return LOCK_SUPP.get(); }
+ /**
+ * 获取构造工具
+ *
+ * @param 缓存的键类型
+ *
+ * @return 构造工具
+ */
+ public static
+ Build build(Class kcla) { return new Build<>(); }
- /*--------------------------------------------------------------------------------------------*/
+ /**
+ * {@link LockMapCache} 构造工具.
+ *
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #sylock(Class)} 绑定缓存的锁的类型
+ * - 使用 {@link #sylock(Supplier)} 绑定缓存的锁的生成方法
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @param 缓存键类型
+ *
+ * @version 0.0.1
+ * @since LockMapCache 0.0.1
+ */
+ @Accessors(chain = true, fluent = true)
+ public final static
+ class Build {
+ /** 缓存引用类型 */
+ @Setter private Class refernce = SoftReference.class;
+ /** 缓存的锁的生成方法 */
+ private Supplier sylock = ObjLock::new;
/**
- * 获取构造工具
- *
- * @param 缓存的键类型
+ * 设置缓存的锁类型
*
- * @return 构造工具
+ * @see #sylock(Supplier)
*/
- public static
- Build build(Class kcla) { return new Build<>(); }
+ @NotNull
+ public
+ Build sylock(Class sylock)
+ { return sylock(new SyLockSupp(sylock)); }
+
+ /** 设置缓存的锁的生成方法 */
+ public
+ Build sylock(@NotNull Supplier syLockSupplier) {
+ this.sylock = syLockSupplier;
+ return this;
+ }
/**
- * {@link LockMapCache} 构造工具.
- *
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #sylock(Class)} 绑定缓存的锁的类型
- * - 使用 {@link #sylock(Supplier)} 绑定缓存的锁的生成方法
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @param 缓存键类型
+ * 构造锁缓存
*
- * @version 0.0.1
- * @since LockMapCache 0.0.1
+ * @return 锁缓存工具
*/
- @Accessors( chain = true, fluent = true )
- public final static
- class Build {
- /** 缓存引用类型 */
- @Setter private Class refernce = SoftReference.class;
- /** 缓存的锁的生成方法 */
- private Supplier sylock = ObjLock::new;
-
- //------------------------------------------------------------------------------------------
-
- /**
- * 设置缓存的锁类型
- *
- * @see #sylock(Supplier)
- */
- @NotNull
- public
- Build sylock(Class sylock)
- { return sylock(new SyLockSupp(sylock)); }
-
- /** 设置缓存的锁的生成方法 */
- public
- Build sylock(@NotNull Supplier syLockSupplier) {
- this.sylock = syLockSupplier;
- return this;
- }
-
- /**
- * 构造锁缓存
- *
- * @return 锁缓存工具
- */
- @NotNull
- public
- LockMapCache build() { return new LockMapCache<>(refernce, sylock); }
- }
+ @NotNull
+ public
+ LockMapCache build() { return new LockMapCache<>(refernce, sylock); }
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/supplier/SCache.java b/src/main/java/fybug/nulll/pdcache/supplier/SCache.java
index c533f218852edff95670d36195833b6f37f63c86..7f5be35b5b2cadc9645b46d0e4e986ddd8480d76 100644
--- a/src/main/java/fybug/nulll/pdcache/supplier/SCache.java
+++ b/src/main/java/fybug/nulll/pdcache/supplier/SCache.java
@@ -1,6 +1,4 @@
package fybug.nulll.pdcache.supplier;
-import org.jetbrains.annotations.NotNull;
-
import java.lang.ref.Reference;
import fybug.nulll.pdcache.CacheOb;
@@ -9,6 +7,7 @@ import fybug.nulll.pdcache.memory.Cache;
import fybug.nulll.pdconcurrent.SyLock;
import fybug.nulll.pdconcurrent.fun.tryConsumer;
import fybug.nulll.pdconcurrent.fun.trySupplier;
+import jakarta.validation.constraints.NotNull;
import lombok.Setter;
import lombok.experimental.Accessors;
@@ -60,95 +59,91 @@ import lombok.experimental.Accessors;
public abstract
class SCache extends MemoryCache {
- /**
- * 构造缓存，指定缓存方式
- *
- * @since 0.0.2
- */
- public
- SCache(@NotNull Class refc) {super(refc); }
+ /**
+ * 构造缓存，指定缓存方式
+ *
+ * @since 0.0.2
+ */
+ public
+ SCache(@NotNull Class refc) { super(refc); }
- /**
- * 构造缓存，指定缓存方式和并发管理
- *
- * @since 0.0.3
- */
- public
- SCache(@NotNull Class refc, @NotNull SyLock syLock)
- { super(refc, syLock); }
+ /**
+ * 构造缓存，指定缓存方式和并发管理
+ *
+ * @since 0.0.3
+ */
+ public
+ SCache(@NotNull Class refc, @NotNull SyLock syLock)
+ { super(refc, syLock); }
- //----------------------------------------------------------------------------------------------
+ //----------------------------------------------------------------------------------------------
- @Override
- @NotNull
- public
- V get(@NotNull tryConsumer run) throws Exception { return super.get(run); }
+ @Override
+ @NotNull
+ public
+ V get(@NotNull tryConsumer run) throws Exception { return super.get(run); }
- @Override
- @NotNull
- public
- V get() throws Exception { return super.get(); }
+ @Override
+ @NotNull
+ public
+ V get() throws Exception { return super.get(); }
- //-----------------------------------
+ /** 创建新的数据 */
+ @NotNull
+ protected abstract
+ V createData() throws Exception;
- /** 创建新的数据 */
- @NotNull
- protected abstract
- V createData() throws Exception;
+ /**
+ * 生成新的缓存
+ *
+ * 使用 {@link #createData()} 创建的数据生成
+ */
+ @Override
+ protected @NotNull
+ V emptyData() throws Exception {
+ // 生成新的数据
+ var v = createData();
+ // 绑定缓存
+ putdata(v);
+ return v;
+ }
- /**
- * 生成新的缓存
- *
- * 使用 {@link #createData()} 创建的数据生成
- */
- @Override
- protected @NotNull
- V emptyData() throws Exception {
- // 生成新的数据
- var v = createData();
- // 绑定缓存
- putdata(v);
- return v;
- }
+ /**
+ * 获取缓存构造工具
+ *
+ * @param 缓存内容的类型
+ *
+ * @return 构造工具
+ */
+ @NotNull
+ public static
+ Build build(Class vc) { return new Build<>(); }
- /*--------------------------------------------------------------------------------------------*/
+ /**
+ * {@link SCache} 构造工具.
+ *
+ * - 使用 {@link #createdata(trySupplier)} 绑定数据生成接口
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since SCache 0.0.1
+ */
+ @Accessors(chain = true, fluent = true)
+ public final static
+ class Build extends CacheOb.Build> {
+ /** 数据生产接口 */
+ @Setter private trySupplier<@NotNull V> createdata;
- /**
- * 获取缓存构造工具
- *
- * @param 缓存内容的类型
- *
- * @return 构造工具
- */
@NotNull
- public static
- Build build(Class vc) {return new Build<>();}
-
- /**
- * {@link SCache} 构造工具.
- *
- * - 使用 {@link #createdata(trySupplier)} 绑定数据生成接口
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @version 0.0.1
- * @since SCache 0.0.1
- */
- @Accessors( chain = true, fluent = true )
- public final static
- class Build extends CacheOb.Build> {
- /** 数据生产接口 */
- @Setter private trySupplier<@NotNull V, Exception> createdata;
-
- @NotNull
- public
- SCache build() {
- return new SCache<>(refernce, lockBy) {
- protected @NotNull
- V createData() throws Exception { return createdata.get(); }
- };
- }
+ public
+ SCache build() {
+ return new SCache<>(refernce, lockBy) {
+ protected @NotNull
+ V createData() throws Exception { return createdata.get(); }
+ };
}
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/supplier/SMapCache.java b/src/main/java/fybug/nulll/pdcache/supplier/SMapCache.java
index cd8d386a41d620a92614994b4eec55c43e7da9ce..a1416f569a7300f7367676c01be69c006681f796 100644
--- a/src/main/java/fybug/nulll/pdcache/supplier/SMapCache.java
+++ b/src/main/java/fybug/nulll/pdcache/supplier/SMapCache.java
@@ -1,14 +1,13 @@
package fybug.nulll.pdcache.supplier;
-import org.jetbrains.annotations.NotNull;
-
import java.lang.ref.Reference;
+import java.util.function.BiConsumer;
import fybug.nulll.pdcache.MapCacheOb;
import fybug.nulll.pdcache.MemoryMapCache;
import fybug.nulll.pdcache.err.CacheError;
import fybug.nulll.pdconcurrent.SyLock;
-import fybug.nulll.pdconcurrent.fun.tryBiConsumer;
import fybug.nulll.pdconcurrent.fun.tryFunction;
+import jakarta.validation.constraints.NotNull;
import lombok.Setter;
import lombok.experimental.Accessors;
@@ -61,86 +60,80 @@ import lombok.experimental.Accessors;
public abstract
class SMapCache extends MemoryMapCache {
- /** 构造缓存，指定缓存方式 */
- public
- SMapCache(@NotNull Class refc) { super(refc); }
-
- /** 构造缓存，指定缓存方式和并发管理 */
- public
- SMapCache(@NotNull Class refc, @NotNull SyLock syLock)
- { super(refc, syLock); }
-
- //----------------------------------------------------------------------------------------------
+ /** 构造缓存，指定缓存方式 */
+ public
+ SMapCache(@NotNull Class refc) { super(refc); }
+
+ /** 构造缓存，指定缓存方式和并发管理 */
+ public
+ SMapCache(@NotNull Class refc, @NotNull SyLock syLock)
+ { super(refc, syLock); }
+
+ @Override
+ @NotNull
+ public
+ V get(@NotNull K key) throws Exception, CacheError { return super.get(key); }
+
+ @Override
+ @NotNull
+ public
+ V get(@NotNull K key, @NotNull BiConsumer run) throws Exception, CacheError
+ { return super.get(key, run); }
+
+ /** 创建新的数据 */
+ @NotNull
+ protected abstract
+ V createData(@NotNull K key) throws Exception;
+
+ @NotNull
+ protected final
+ V emptyData(@NotNull K key) throws Exception, CacheError {
+ if ( isClose() )
+ throw new CacheError();
+
+ // 生成新的数据
+ var v = createData(key);
+ putdata(key, v);
+ return v;
+ }
+
+ /**
+ * 获取缓存构造工具
+ *
+ * @param 键的类型
+ * @param 缓存内容的类型
+ *
+ * @return 构造工具
+ */
+ @NotNull
+ public static
+ Build build(Class kc, Class vc) { return new Build<>(); }
+
+ /**
+ * {@link SMapCache} 构造工具.
+ *
+ * - 使用 {@link #createdata(tryFunction)} 方法绑定数据生成接口
+ * - 使用 {@link #refernce(Class)} 绑定缓存方式
+ * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
+ * - 使用 {@link #build()} 进行构造
+ *
+ *
+ * @version 0.0.1
+ * @since SMapCache 0.0.1
+ */
+ @Accessors(chain = true, fluent = true)
+ public static final
+ class Build extends MapCacheOb.Build> {
+ /** 数据生成接口 */
+ @Setter private tryFunction<@NotNull K, @NotNull V> createdata;
- @Override
@NotNull
public
- V get(@NotNull K key) throws Exception, CacheError { return super.get(key); }
-
- @Override
- @NotNull
- public
- V get(@NotNull K key, @NotNull tryBiConsumer run) throws Exception, CacheError
- { return super.get(key, run); }
-
- //--------------------------------
-
- /** 创建新的数据 */
- @NotNull
- protected abstract
- V createData(@NotNull K key) throws Exception;
-
- @NotNull
- protected final
- V emptyData(@NotNull K key) throws Exception, CacheError {
- if (isClose())
- throw new CacheError();
-
- // 生成新的数据
- var v = createData(key);
- putdata(key, v);
- return v;
- }
-
- /*--------------------------------------------------------------------------------------------*/
-
- /**
- * 获取缓存构造工具
- *
- * @param 键的类型
- * @param 缓存内容的类型
- *
- * @return 构造工具
- */
- @NotNull
- public static
- Build build(Class kc, Class vc) {return new Build<>();}
-
- /**
- * {@link SMapCache} 构造工具.
- *
- * - 使用 {@link #createdata(tryFunction)} 方法绑定数据生成接口
- * - 使用 {@link #refernce(Class)} 绑定缓存方式
- * - 使用 {@link #lockBy(SyLock)} 绑定并发管理
- * - 使用 {@link #build()} 进行构造
- *
- *
- * @version 0.0.1
- * @since SMapCache 0.0.1
- */
- @Accessors( chain = true, fluent = true )
- public static final
- class Build extends MapCacheOb.Build> {
- /** 数据生成接口 */
- @Setter private tryFunction<@NotNull K, @NotNull V, Exception> createdata;
-
- @NotNull
- public
- SMapCache build() {
- return new SMapCache<>(refernce, lockBy) {
- protected @NotNull
- V createData(@NotNull K key) throws Exception { return createdata.apply(key); }
- };
- }
+ SMapCache build() {
+ return new SMapCache<>(refernce, lockBy) {
+ protected @NotNull
+ V createData(@NotNull K key) throws Exception { return createdata.apply(key); }
+ };
}
+ }
}
diff --git a/src/main/java/fybug/nulll/pdcache/supplier/SyLockSupp.java b/src/main/java/fybug/nulll/pdcache/supplier/SyLockSupp.java
index e3602cfbc4339bacf7776996e35483455a66eb7e..985abe6f4a79ff48e154751f9a5153982b34d770 100644
--- a/src/main/java/fybug/nulll/pdcache/supplier/SyLockSupp.java
+++ b/src/main/java/fybug/nulll/pdcache/supplier/SyLockSupp.java
@@ -15,20 +15,20 @@ import fybug.nulll.pdconcurrent.SyLock;
*/
final
class SyLockSupp implements Supplier {
- // 锁的类型
- private final Class LOCK_CLASS;
+ // 锁的类型
+ private final Class LOCK_CLASS;
- /** 指定锁的类 */
- SyLockSupp(Class sylock) { LOCK_CLASS = sylock; }
+ /** 指定锁的类 */
+ SyLockSupp(Class sylock) { LOCK_CLASS = sylock; }
- @Override
- public
- SyLock get() {
- try {
- return LOCK_CLASS.getConstructor().newInstance();
- } catch ( Exception e ) {
- e.printStackTrace();
- }
- return SyLock.newObjLock();
+ @Override
+ public
+ SyLock get() {
+ try {
+ return LOCK_CLASS.getConstructor().newInstance();
+ } catch ( Exception e ) {
+ e.printStackTrace();
}
+ return SyLock.newObjLock();
+ }
}
diff --git a/src/test/java/fybug/nulll/pdcache/RunTest.java b/src/test/java/fybug/nulll/pdcache/RunTest.java
deleted file mode 100644
index bad646085c175a3c89686f1d4e0de05baf4e4297..0000000000000000000000000000000000000000
--- a/src/test/java/fybug/nulll/pdcache/RunTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package fybug.nulll.pdcache;
-import org.junit.Assert;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.io.StringWriter;
-
-import fybug.nulll.pdcache.memory.memoryTest;
-import fybug.nulll.pdcache.supplier.suppilerTest;
-
-@RunWith( Suite.class )
-@Suite.SuiteClasses( {memoryTest.class, suppilerTest.class} )
-public
-class RunTest {
- public static PrintWriter from;
- public static PrintWriter to;
-
- public static StringWriter from_s;
- public static StringWriter to_s;
-
- public static
- void init() {
- from = new PrintWriter(from_s = new StringWriter());
- to = new PrintWriter(to_s = new StringWriter());
- }
-
- public static
- void destruction() throws IOException {
- suppilerTest.destruction();
-
- from.close();
- from = null;
- from_s.close();
- from_s = null;
-
- to.close();
- to = null;
- to_s.close();
- to_s = null;
- }
-
- public static
- void check() { Assert.assertEquals(from_s.toString(), to_s.toString()); }
-}
diff --git a/src/test/java/fybug/nulll/pdcache/memory/CacheTest.java b/src/test/java/fybug/nulll/pdcache/memory/CacheTest.java
deleted file mode 100644
index fa4874b99416adf3a12d26b954c383ee837a0058..0000000000000000000000000000000000000000
--- a/src/test/java/fybug/nulll/pdcache/memory/CacheTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package fybug.nulll.pdcache.memory;
-import org.jetbrains.annotations.NotNull;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.lang.ref.WeakReference;
-
-import fybug.nulll.pdcache.CanClean;
-import fybug.nulll.pdcache.PDCache;
-
-import static fybug.nulll.pdcache.RunTest.check;
-import static fybug.nulll.pdcache.RunTest.destruction;
-import static fybug.nulll.pdcache.RunTest.from;
-import static fybug.nulll.pdcache.RunTest.init;
-import static fybug.nulll.pdcache.RunTest.to;
-
-public
-class CacheTest {
- private Cache