调整架构使其更容易维护，调整注释

Author: PatternDirClean

README.md

@@ -1,4 +1,6 @@
+<p align="center">
 <img src="https://images.gitee.com/uploads/images/2020/1022/231243_f2ae30da_2071767.png" width="229" height="210" alt="Icon"/>
+</p>
 
 # PDConcurrent
 

build.gradle

@@ -8,7 +8,7 @@ tasks.withType(JavaCompile).configureEach {
 }
 
 group 'fybug.nulll'
-version = '0.1.0'
+version = '0.1.3'
 
 java {
   toolchain {
@@ -53,12 +53,13 @@ dependencies {
   // lombok
   testCompileOnly "org.projectlombok:lombok:+"
   testAnnotationProcessor "org.projectlombok:lombok:+"
-  testRuntimeOnly "org.junit.jupiter:junit-jupiter:5.12.0+"
+  testImplementation platform('org.junit:junit-bom:5.10.0')
+  testRuntimeOnly "org.junit.jupiter:junit-jupiter:5.12.0-RC2"
 }
 
 test {
   dependencies {
-    testImplementation "org.junit.jupiter:junit-jupiter:5.12.0+"
+    testImplementation "org.junit.jupiter:junit-jupiter:5.12.0-RC2"
   }
   useJUnitPlatform()
 }

jar/PDConcurrent_bin.jar

@@ -1,15 +1,17 @@
 package fybug.nulll.pdconcurrent;
 import fybug.nulll.pdconcurrent.e.LockType;
-import fybug.nulll.pdconcurrent.i.ReadWriteLock;
-import fybug.nulll.pdconcurrent.i.TryReadWriteLock;
+import fybug.nulll.pdconcurrent.i.simple.ReadLockSimple;
+import fybug.nulll.pdconcurrent.i.simple.TryReadLockSimple;
+import fybug.nulll.pdconcurrent.i.simple.TryWriteLockSimple;
+import fybug.nulll.pdconcurrent.i.simple.WriteLockSimple;
 import fybug.nulll.pdconcurrent.lock.ObjLock;
 import fybug.nulll.pdconcurrent.lock.RWLock;
 import fybug.nulll.pdconcurrent.lock.ReLock;
 import jakarta.validation.constraints.NotNull;
 
 /**
  * <h2>并发管理.</h2>
- * 通过传入回调的方式隐藏内部的并发管理方法，并支持复用内部的try块，通过传入的回调插入到catch，finally块中执行<br/>
+ * 通过传入回调的方式隐藏内部的并发管理方法，并支持复用内部的 try 块，通过传入的回调插入到 catch，finally 块中执行<br/>
  * {@code lock()}方法用于根据传入的{@link LockType}申请不同的锁类型进行执行<br/>
  * {@code read()}方法用于使用读锁执行，{@code write()}用于使用写锁执行，只有在使用读写锁实现{@link RWLock}才有区别。其余实现两个之间无区别<br/>
  * {@code trylock()}类型的方法为尝试获取锁的实现，这意味着并不是一定能获取到锁，但也意味着不需要等待<br/>
@@ -18,19 +20,19 @@
  * 使用 {@code new**Lock()} 的方法获取不同并发管理的实例<br/>
  *
  * @author fybug
- * @version 0.1.2
+ * @version 0.1.3
  * @since PDConcurrent 0.0.1
  */
+@SuppressWarnings("unused")
 public
-interface SyLock extends ReadWriteLock, TryReadWriteLock {
+interface SyLock extends ReadLockSimple, WriteLockSimple, TryReadLockSimple, TryWriteLockSimple {
   /**
    * 获取传统并发实现
    *
    * @return 获取的并发控制对象
    *
    * @see ObjLock
    */
-  @SuppressWarnings("unused")
   @NotNull
   static
   ObjLock newObjLock() { return new ObjLock(); }
@@ -42,7 +44,6 @@ interface SyLock extends ReadWriteLock, TryReadWriteLock {
    *
    * @see ReLock
    */
-  @SuppressWarnings("unused")
   @NotNull
   static
   ReLock newReLock() { return new ReLock(); }
@@ -54,7 +55,6 @@ interface SyLock extends ReadWriteLock, TryReadWriteLock {
    *
    * @see RWLock
    */
-  @SuppressWarnings("unused")
   @NotNull
   static
   RWLock newRWLock() { return new RWLock(); }

jar/PDConcurrent_sources.jar

@@ -10,15 +10,16 @@
 
 /**
  * <h2>基础锁管理.</h2>
- * 通过传入回调的方式隐藏内部的并发管理方法，并支持复用内部的try块，通过传入的回调插入到catch，finally块中执行<br/>
- * {@code lock()}方法用于根据传入的{@link LockType}申请不同的锁类型进行执行<br/>
+ * 通过传入回调的方式隐藏内部的并发管理方法，并支持复用内部的 try 块，通过传入的回调插入到 catch，finally 块中执行<br/>
+ * {@code lock()} 方法用于根据传入的 {@link LockType} 申请不同的锁类型进行执行<br/>
  * 有可抛出异常的方法变体，可在传入的接口中抛出异常
  *
  * @author fybug
- * @version 0.0.1
+ * @version 0.0.2
  * @see LockType
  * @since i 0.0.1
  */
+public
 interface Lock {
   /**
    * 使用锁执行指定回调
@@ -44,11 +45,6 @@ <R> R lock(@NotNull LockType lockType, @NotNull trySupplier<R> run, @Nullable Fu
    * 使用锁执行指定回调
    * <p>
    * {@link #lock(LockType, trySupplier, Function, Function)}的无返回变体
-   *
-   * @param lockType 锁类型
-   * @param run      执行的回调
-   * @param catchby  进入catch块后的回调，传入当前异常
-   * @param finaby   进入finally块后的回调
    */
   default
   void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Consumer<Exception> catchby,
@@ -85,33 +81,10 @@ void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Consum
    */
   <R> R lock(@NotNull LockType lockType, @NotNull trySupplier<R> run, @Nullable Function<R, R> finaby) throws Exception;
 
-  /**
-   * 使用锁执行指定回调
-   * <p>
-   * {@link #lock(LockType, trySupplier, Function)}的简易变体
-   *
-   * @param lockType 锁类型
-   * @param run      带返回的回调
-   * @param <R>      要返回的数据类型
-   *
-   * @return 回调返回的内容，遇到异常不返回
-   *
-   * @throws Exception 异常类型根据实际运行时回调抛出决定
-   */
-  default
-  <R> R lock(@NotNull LockType lockType, @NotNull trySupplier<R> run) throws Exception
-  { return lock(lockType, run, null); }
-
   /**
    * 使用锁执行指定回调
    * <p>
    * {@link #lock(LockType, trySupplier, Function)}的无返回变体
-   *
-   * @param lockType 锁类型
-   * @param run      执行的回调
-   * @param finaby   进入finally块后的回调
-   *
-   * @throws Exception 异常类型根据实际运行时回调抛出决定
    */
   default
   void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Runnable finaby) throws Exception {
@@ -123,18 +96,4 @@ void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Runnab
       return null;
     });
   }
-
-  /**
-   * 使用锁执行指定回调
-   * <p>
-   * {@link #lock(LockType, tryRunnable, Runnable)}的简易变体
-   *
-   * @param lockType 锁类型
-   * @param run      执行的回调
-   *
-   * @throws Exception 异常类型根据实际运行时回调抛出决定
-   */
-  default
-  void lock(@NotNull LockType lockType, @NotNull tryRunnable run) throws Exception
-  { lock(lockType, run, null); }
 }

src/main/java/fybug/nulll/pdconcurrent/SyLock.java

@@ -0,0 +1,60 @@
+package fybug.nulll.pdconcurrent.i;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import fybug.nulll.pdconcurrent.e.LockType;
+import fybug.nulll.pdconcurrent.fun.tryRunnable;
+import fybug.nulll.pdconcurrent.fun.trySupplier;
+import fybug.nulll.pdconcurrent.i.simple.LockSimple;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
+
+/**
+ * <h2>并发管理读锁支持拓展.</h2>
+ * {@link Lock}的拓展，增加 {@code read()} 类方法用于隐藏 {@link LockType} 参数
+ *
+ * @author fybug
+ * @version 0.0.1
+ * @see LockType#READ
+ * @see Lock
+ * @since i 0.0.2
+ */
+@SuppressWarnings("unused")
+public
+interface ReadLock extends LockSimple {
+  /**
+   * 使用读锁执行指定回调
+   * <p>
+   * {@link #lock(LockType, trySupplier, Function, Function)}指定读锁的变种
+   */
+  default
+  <R> R read(@NotNull trySupplier<R> run, @Nullable Function<Exception, R> catchby, @Nullable Function<R, R> finaby)
+  { return lock(LockType.READ, run, catchby, finaby); }
+
+  /**
+   * 使用读锁执行指定回调
+   * <p>
+   * {@link #lock(LockType, tryRunnable, Consumer, Runnable)}指定读锁的变种
+   */
+  default
+  void read(@NotNull tryRunnable run, @Nullable Consumer<Exception> catchby, @Nullable Runnable finaby)
+  { lock(LockType.READ, run, catchby, finaby); }
+
+  /**
+   * 使用读锁执行指定回调
+   * <p>
+   * {@link #lock(LockType, trySupplier, Function)}指定读锁的变种
+   */
+  default
+  <R> R read(@NotNull trySupplier<R> run, @Nullable Function<R, R> finaby) throws Exception
+  { return lock(LockType.READ, run, finaby); }
+
+  /**
+   * 使用读锁执行指定回调
+   * <p>
+   * {@link #lock(LockType, tryRunnable, Runnable)}指定读锁的变种
+   */
+  default
+  void read(@NotNull tryRunnable run, @Nullable Runnable finaby) throws Exception
+  { lock(LockType.READ, run, finaby); }
+}