run) {
- synchronized ( LOCK ){
- return run.get();
- }
- }
+ /**
+ * 构建并发管理
+ *
+ * 使用一个新的{@link Object}
+ */
+ public
+ ObjLock() { this(new Object()); }
- //----------------------------------------------------------------------------------------------
+ /**
+ * 构建并发管理
+ *
+ * @param lock 用作锁的对象
+ *
+ * @since 0.1.0
+ */
+ public
+ ObjLock(@NotNull Object lock) { LOCK = lock; }
- @Override
- public
- T tryread(@NotNull Class ecla, @NotNull trySupplier run)
- throws E
- { return tryrun(ecla, run); }
+ //----------------------------------------------------------------------------------------------
- @Override
- public
- T trywrite(@NotNull Class ecla, @NotNull trySupplier run)
- throws E
- { return tryrun(ecla, run); }
+ /**
+ * {@inheritDoc}
+ *
+ * @param lockType {@inheritDoc}
+ * @param run {@inheritDoc}
+ * @param catchby {@inheritDoc}
+ * @param finaby {@inheritDoc}
+ * @param {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ *
+ * @implNote 使用 {@code synchronized( Object )} 实现的隐式并发域
+ * @see SyLock#lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ @Override
+ public
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function catchby,
+ @Nullable Function finaby)
+ {
+ R o = null;
+ // 不上锁
+ if ( lockType == LockType.NOLOCK ) {
+ try {
+ // 主要内容
+ o = run.get();
+ } catch ( Exception e ) {
+ // 异常处理
+ if ( catchby != null )
+ o = catchby.apply(e);
+ } finally {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ }
+ } else {
+ // 上锁
+ synchronized ( LOCK ){
+ try {
+ // 主要内容
+ o = run.get();
+ } catch ( Exception e ) {
+ // 异常处理
+ if ( catchby != null )
+ o = catchby.apply(e);
+ } finally {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ }
+ }
+ }
+ return o;
+ }
- // 读写一致
- private
- T tryrun(Class ecla, trySupplier run) throws E {
- synchronized ( LOCK ){
- return run.get();
- }
- }
+ /**
+ * {@inheritDoc}
+ *
+ * @param lockType {@inheritDoc}
+ * @param run {@inheritDoc}
+ * @param finaby {@inheritDoc}
+ * @param {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ *
+ * @implNote 使用 {@code synchronized( Object )} 实现的隐式并发域
+ * @see SyLock#trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ @Override
+ public
+ R trylock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function finaby) throws Exception {
+ R o = null;
+ // 不上锁
+ if ( lockType == LockType.NOLOCK ) {
+ try {
+ // 主要内容
+ o = run.get();
+ } finally {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ }
+ } else {
+ // 上锁
+ synchronized ( LOCK ){
+ try {
+ // 主要内容
+ o = run.get();
+ } finally {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ }
+ }
+ }
+ return o;
+ }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/RWLock.java b/src/main/java/fybug/nulll/pdconcurrent/RWLock.java
index bff3d7722972f2e15f29605c001f387aa76c45ce..bbd33e30dd6fbaedd6122c0327b799d651241729 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/RWLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/RWLock.java
@@ -1,123 +1,316 @@
package fybug.nulll.pdconcurrent;
-import org.jetbrains.annotations.NotNull;
-
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.function.Supplier;
+import java.util.function.Function;
+import fybug.nulll.pdconcurrent.e.LockType;
import fybug.nulll.pdconcurrent.fun.trySupplier;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
import lombok.Getter;
/**
- * 使用读写锁 {@link ReentrantReadWriteLock} 实现的并发管理
- * 使用并发管理：
- * public static
- * void main(String[] args) {
- * var lock = new RWLock();
- * lock.read(() -> System.out.println("adsa"));
- * lock.write(() -> System.out.println("adsa"));
- * }
- * 不使用：
- * public static
- * void main(String[] args) {
- * var lock = new ReentrantReadWriteLock();
- * lock.readLock().lock();
- * try {
- * System.out.println("adsa");
- * } finally {
- * lock.readLock().unlock();
- * }
- * lock.writeLock().lock();
- * try {
- * System.out.println("adsa");
- * } finally {
- * lock.writeLock().unlock();
- * }
- * }
+ * 使用{@link ReentrantReadWriteLock}实现的并发管理.
+ * 使用{@link ReentrantReadWriteLock}实现并发域，读写锁均为标准实现，支持通过{@link #toread()}进行锁降级
+ * 使用了可中断的上锁操作{@link ReentrantReadWriteLock.ReadLock#lockInterruptibly()}和{@link ReentrantReadWriteLock.WriteLock#lockInterruptibly()}
+ * 支持使用{@link #newReadCondition()}{@link #newWriteCondition()}获取{@link Condition}，通过{@link #isLocked()}{@link #isWriteLocked()}{@link #isReadLocked()}检查是否被占用
+ *
+ * 使用并发管理：
+ * {@snippet lang = java:
+ * public static void main(String[] args) {
+ * var lock = new RWLock();
+ * // 使用读锁
+ * lock.read(() -> System.out.println("adsa"));
+ * // 使用写锁
+ * lock.write(() -> System.out.println("adsa"));
+ * }}
+ * 不使用：
+ * {@snippet lang = java:
+ * import java.util.concurrent.locks.ReentrantReadWriteLock;
+ * public static void main(String[] args) {
+ * var lock = new ReentrantReadWriteLock();
+ * // 使用读锁
+ * try {
+ * lock.readLock().lock();
+ * System.out.println("adsa");
+ * } finally {
+ * lock.readLock().unlock();
+ * }
+ * // 使用写锁
+ * try {
+ * lock.writeLock().lock();
+ * System.out.println("adsa");
+ * } finally {
+ * lock.writeLock().unlock();
+ * }
+ * }}
*
* @author fybug
- * @version 0.0.1
+ * @version 0.1.0
+ * @see SyLock
+ * @see LockType
+ * @see ReentrantReadWriteLock
+ * @see ReentrantReadWriteLock.ReadLock
+ * @see ReentrantReadWriteLock.WriteLock
* @since PDConcurrent 0.0.1
*/
+@Getter
public
class RWLock implements SyLock {
+ /** 锁 */
+ private final ReentrantReadWriteLock LOCK;
+ /** 读锁 */
+ private final ReentrantReadWriteLock.ReadLock Read_LOCK;
+ /** 写锁 */
+ private final ReentrantReadWriteLock.WriteLock Write_LOCK;
+ /**
+ * 每个线程的锁状态记录
+ *
+ * 读锁为{@code 1}
+ * 写锁为{@code 2}
+ */
+ private final ThreadLocal LOCK_STATE = new ThreadLocal<>();
+
+ /**
+ * 构建并发管理
+ *
+ * 使用非公平锁
+ */
+ public
+ RWLock() { this(false); }
+
+ /**
+ * 构造并发处理
+ *
+ * @param fair 是否使用公平锁
+ */
+ public
+ RWLock(boolean fair) { this(new ReentrantReadWriteLock(fair)); }
+
+ /**
+ * 构造并发处理
+ *
+ * @param lock 使用的锁
+ *
+ * @since 0.1.0
+ */
+ public
+ RWLock(@NotNull ReentrantReadWriteLock lock) {
+ LOCK = lock;
+ Read_LOCK = LOCK.readLock();
+ Write_LOCK = LOCK.writeLock();
+ }
+
+ //----------------------------------------------------------------------------------------------
+
+ /**
+ * {@inheritDoc}
+ *
+ * @param lockType {@inheritDoc}
+ * @param run {@inheritDoc}
+ * @param catchby {@inheritDoc}
+ * @param finaby {@inheritDoc}
+ * @param {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ *
+ * @implNote 使用 {@link ReentrantReadWriteLock} 实现的并发域，上锁通过{@link #tolock(LockType)}进行
+ * @see SyLock#lock(LockType, trySupplier, Function, Function)
+ * @see #tolock(LockType)
+ * @see #tounlock()
+ * @since 0.1.0
+ */
+ @Override
+ public
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function catchby,
+ @Nullable Function finaby)
+ {
+ R o = null;
+ // 清空当前线程的状态
+ LOCK_STATE.remove();
+ try {
+ // 上锁
+ tolock(lockType);
+ // 主要内容
+ o = run.get();
+ } catch ( Exception e ) {
+ // 异常处理
+ if ( catchby != null )
+ o = catchby.apply(e);
+ } finally {
+ // 防止错误
+ try {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ } finally {
+ // 解锁
+ tounlock();
+ }
+ }
+ return o;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @param lockType {@inheritDoc}
+ * @param run {@inheritDoc}
+ * @param finaby {@inheritDoc}
+ * @param {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ *
+ * @implNote 使用 {@link ReentrantReadWriteLock} 实现的并发域，上锁通过{@link #tolock(LockType)}进行
+ * @see SyLock#trylock(LockType, trySupplier, Function)
+ * @see #tolock(LockType)
+ * @see #tounlock()
+ * @since 0.1.0
+ */
+ @Override
+ public
+ R trylock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function finaby) throws Exception {
+ R o = null;
+ // 清空当前线程的状态
+ LOCK_STATE.remove();
+ try {
+ // 上锁
+ tolock(lockType);
+ // 主要内容
+ o = run.get();
+ } finally {
+ // 防止错误
+ try {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ } finally {
+ // 解锁
+ tounlock();
+ }
+ }
+ return o;
+ }
+
+ /**
+ * 根据指定类型上锁
+ *
+ * 使用了可中断的上锁操作{@link ReentrantReadWriteLock.ReadLock#lockInterruptibly()}和{@link ReentrantReadWriteLock.WriteLock#lockInterruptibly()}
+ * 同时更新{@link #LOCK_STATE}记录
+ *
+ * @param lockType 锁类型
+ *
+ * @throws InterruptedException 上锁过程中被中断
+ * @see #LOCK_STATE
+ * @see LockType
+ * @since 0.1.0
+ */
+ private
+ void tolock(@NotNull LockType lockType) throws InterruptedException {
+ if ( lockType != LockType.NOLOCK ) {
+ if ( lockType == LockType.READ ) {
+ // 读锁
+ Read_LOCK.lockInterruptibly();
+ LOCK_STATE.set((short) 1);
+ } else {
+ // 写锁
+ Write_LOCK.lockInterruptibly();
+ LOCK_STATE.set((short) 2);
+ }
+ }
+ }
+
+ /**
+ * 根据状态解锁
+ *
+ * 根据{@link #LOCK_STATE}的状态调用对应的解锁动作
+ * 成功后清空{@link #LOCK_STATE}内容
+ *
+ * @see #LOCK_STATE
+ * @since 0.1.0
+ */
+ private
+ void tounlock() {
+ // 根据实际状态解锁
+ if ( LOCK_STATE.get() == 1 )
+ Read_LOCK.unlock();
+ else if ( LOCK_STATE.get() == 2 )
+ Write_LOCK.unlock();
+ // 清除记录数据
+ LOCK_STATE.remove();
+ }
+
+ /**
+ * 转为读锁
+ *
+ * 如果当前状态为写锁则会降级为读锁，否则不进行操作
+ *
+ * @return 是否成功降级
+ *
+ * @see #LOCK_STATE
+ * @since 0.1.0
+ */
+ public
+ boolean toread() {
+ // 转为读锁
+ if ( LOCK_STATE.get() == 2 ) {
+ Read_LOCK.lock();
+ Write_LOCK.unlock();
+ LOCK_STATE.set((short) 1);
+ return true;
+ }
+ return false;
+ }
+
+ //----------------------------------------------------------------------------------------------
+
+ /**
+ * 检查锁是否被占用
+ *
+ * @return 是否被占用
+ *
+ * @since 0.1.0
+ */
+ public
+ boolean isLocked() { return LOCK_STATE.get() != null && (LOCK_STATE.get() == 1 || LOCK_STATE.get() == 2); }
+
+ /**
+ * 检查读锁是否被占用
+ *
+ * @return 是否被占用
+ *
+ * @since 0.1.0
+ */
+ public
+ boolean isReadLocked() { return LOCK_STATE.get() == 1; }
+
+ /**
+ * 检查写锁是否被占用
+ *
+ * @return 是否被占用
+ *
+ * @since 0.1.0
+ */
+ public
+ boolean isWriteLocked() { return LOCK_STATE.get() == 2; }
+
+ /**
+ * 获取读锁{@link Condition}
+ *
+ * @see ReentrantReadWriteLock.ReadLock#newCondition()
+ * @since 0.1.0
+ */
+ @NotNull
+ public
+ Condition newReadCondition() { return Read_LOCK.newCondition(); }
- @Getter final private ReentrantReadWriteLock LOCK;
- @Getter final private ReentrantReadWriteLock.ReadLock Read_LOCK;
- @Getter final private ReentrantReadWriteLock.WriteLock Write_LOCK;
-
- public
- RWLock() {this(false);}
-
- /** 生成并发管理，并指定是否使用公平锁 */
- public
- RWLock(boolean fair) {
- LOCK = new ReentrantReadWriteLock(false);
- Read_LOCK = LOCK.readLock();
- Write_LOCK = LOCK.writeLock();
- }
-
- //----------------------------------------------------------------------------------------------
-
- @Override
- public
- T read(@NotNull Supplier run) {
- try {
- Read_LOCK.lock();
- return run.get();
- } finally {
- Read_LOCK.unlock();
- }
- }
-
- @Override
- public
- T write(@NotNull Supplier run) {
- try {
- Write_LOCK.lock();
- return run.get();
- } finally {
- Write_LOCK.unlock();
- }
- }
-
- //----------------------------------------------------------------------------------------------
-
- @Override
- public
- T tryread(@NotNull Class ecla, @NotNull trySupplier run)
- throws E
- {
- try {
- Read_LOCK.lock();
- return run.get();
- } finally {
- Read_LOCK.unlock();
- }
- }
-
- @Override
- public
- T trywrite(@NotNull Class ecla, @NotNull trySupplier run)
- throws E
- {
- try {
- Write_LOCK.lock();
- return run.get();
- } finally {
- Write_LOCK.unlock();
- }
- }
-
- //----------------------------------------------------------------------------------------------
-
- /** 获取 {@link Condition} */
- @NotNull
- public
- Condition newReadCondition() {return Read_LOCK.newCondition();}
-
- /** 获取 {@link Condition} */
- @NotNull
- public
- Condition newWriteCondition() {return Write_LOCK.newCondition();}
+ /**
+ * 获取写锁{@link Condition}
+ *
+ * @see ReentrantReadWriteLock.WriteLock#newCondition()
+ * @since 0.1.0
+ */
+ @NotNull
+ public
+ Condition newWriteCondition() { return Write_LOCK.newCondition(); }
}
\ No newline at end of file
diff --git a/src/main/java/fybug/nulll/pdconcurrent/ReLock.java b/src/main/java/fybug/nulll/pdconcurrent/ReLock.java
index b5208f0c8fdc25feccdf9afdf03f1ba7910d0512..02deb448788e21a8a8c7c03dd46376a019971f14 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/ReLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/ReLock.java
@@ -1,100 +1,180 @@
package fybug.nulll.pdconcurrent;
-import org.jetbrains.annotations.NotNull;
-
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Supplier;
+import java.util.function.Function;
+import fybug.nulll.pdconcurrent.e.LockType;
import fybug.nulll.pdconcurrent.fun.trySupplier;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
import lombok.Getter;
/**
- * 使用 {@link ReentrantLock} 实现的并发管理
- * 使用并发管理：
- * public static
- * void main(String[] args) {
- * var lock = new ReLock();
- * lock.read(() -> System.out.println("asdas"));
- * }
- * 不使用：
- * public static
- * void main(String[] args) {
- * var lock = new ReentrantLock();
- * lock.lock();
- * try {
- * System.out.println("asdas");
- * } finally {
- * lock.unlock();
- * }
- * }
+ * 使用{@link ReentrantLock}实现的并发管理.
+ * 使用{@link ReentrantLock}实现并发域，读写锁均为同一个实现
+ * 使用了可中断的上锁操作{@link ReentrantLock#lockInterruptibly()}
+ * 支持使用{@link #newCondition()}获取{@link Condition}，通过{@link #isLocked()}检查是否被占用
+ *
+ * 使用并发管理：
+ * {@snippet lang = java:
+ * public static void main(String[] args) {
+ * var lock = new ReLock();
+ * lock.read(() -> System.out.println("asdas"));
+ * }}
+ * 不使用：
+ * {@snippet lang = java:
+ * import java.util.concurrent.locks.ReentrantLock;
+ * public static void main(String[] args) {
+ * var lock = new ReentrantLock();
+ * lock.lock();
+ * try {
+ * System.out.println("asdas");
+ * } finally {
+ * lock.unlock();
+ * }
+ * }}
*
* @author fybug
- * @version 0.0.1
+ * @version 0.1.0
+ * @see SyLock
+ * @see ReentrantLock
* @since PDConcurrent 0.0.1
*/
+@Getter
public
class ReLock implements SyLock {
-
- // 锁
- @Getter private final ReentrantLock LOCK;
-
- public
- ReLock() {this(false);}
-
- /** 构造并发处理，并决定使用公平锁还是非公平锁 */
- public
- ReLock(boolean fair) { LOCK = new ReentrantLock(fair); }
-
- //----------------------------------------------------------------------------------------------
-
- @Override
- public
- T read(@NotNull Supplier run) { return run(run); }
-
- @Override
- public
- T write(@NotNull Supplier run) { return run(run); }
-
- // 读写无区别
- private
- T run(Supplier run) {
- try {
- LOCK.lock();
- return run.get();
- } finally {
- LOCK.unlock();
- }
- }
-
- //------------------------------------------
-
- @Override
- public
- T tryread(@NotNull Class ecla, @NotNull trySupplier run)
- throws E
- { return tryrun(ecla, run); }
-
- @Override
- public
- T trywrite(@NotNull Class ecla, @NotNull trySupplier run)
- throws E
- { return tryrun(ecla, run); }
-
- // 读写无区别
- private
- T tryrun(Class ecla, trySupplier run) throws E {
- try {
- LOCK.lock();
- return run.get();
- } finally {
- LOCK.unlock();
- }
- }
-
- //-------------------------------------------
-
- /** 获取 {@link Condition} */
- @NotNull
- public
- Condition newCondition() {return LOCK.newCondition();}
+ /** 锁 */
+ private final ReentrantLock LOCK;
+
+ /**
+ * 构建并发管理
+ *
+ * 使用非公平锁
+ */
+ public
+ ReLock() { this(false); }
+
+ /**
+ * 构造并发处理
+ *
+ * @param fair 是否使用公平锁
+ */
+ public
+ ReLock(boolean fair) { this(new ReentrantLock(fair)); }
+
+ /**
+ * 构造并发处理
+ *
+ * @param LOCK 使用的锁
+ *
+ * @since 0.1.0
+ */
+ public
+ ReLock(@NotNull ReentrantLock LOCK) { this.LOCK = LOCK; }
+
+ //----------------------------------------------------------------------------------------------
+
+ /**
+ * {@inheritDoc}
+ *
+ * @param lockType {@inheritDoc}
+ * @param run {@inheritDoc}
+ * @param catchby {@inheritDoc}
+ * @param finaby {@inheritDoc}
+ * @param {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ *
+ * @implNote 使用 {@link ReentrantLock} 实现的并发域，使用了{@link ReentrantLock#lockInterruptibly()}进行可中断的上锁操作
+ * @see SyLock#lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ @Override
+ public
+ R lock(@NotNull LockType lockType, trySupplier run, @Nullable Function catchby,
+ @Nullable Function finaby)
+ {
+ R o = null;
+ try {
+ // 上锁
+ if ( lockType != LockType.NOLOCK )
+ LOCK.lockInterruptibly();
+ // 主要内容
+ o = run.get();
+ } catch ( Exception e ) {
+ // 异常处理
+ if ( catchby != null )
+ o = catchby.apply(e);
+ } finally {
+ // 防止错误
+ try {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ } finally {
+ // 解锁
+ if ( lockType != LockType.NOLOCK && LOCK.isLocked() )
+ LOCK.unlock();
+ }
+ }
+ return o;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @param lockType {@inheritDoc}
+ * @param run {@inheritDoc}
+ * @param finaby {@inheritDoc}
+ * @param {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ *
+ * @implNote 使用 {@link ReentrantLock} 实现的并发域，使用了{@link ReentrantLock#lockInterruptibly()
+ * @see SyLock#trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ @Override
+ public
+ R trylock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function finaby) throws Exception {
+ R o = null;
+ try {
+ // 上锁
+ if ( lockType != LockType.NOLOCK )
+ LOCK.lockInterruptibly();
+ // 主要内容
+ o = run.get();
+ } finally {
+ // 防止错误
+ try {
+ // 收尾
+ if ( finaby != null )
+ o = finaby.apply(o);
+ } finally {
+ // 解锁
+ if ( lockType != LockType.NOLOCK && LOCK.isLocked() )
+ LOCK.unlock();
+ }
+ }
+ return o;
+ }
+
+ //----------------------------------------------------------------------------------------------
+
+ /**
+ * 获取{@link Condition}
+ *
+ * @see ReentrantLock#newCondition()
+ */
+ @NotNull
+ public
+ Condition newCondition() { return LOCK.newCondition(); }
+
+ /**
+ * 检查锁是否被占用
+ *
+ * @return 是否被占用
+ */
+ public
+ boolean isLocked() { return LOCK.isLocked(); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/SyLock.java b/src/main/java/fybug/nulll/pdconcurrent/SyLock.java
index 620ccc0f5c9c0fc7757d805b9fc8d5e18ac5114f..1d7929ac62976b1efc7460b38e0153a5c10c542f 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/SyLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/SyLock.java
@@ -1,311 +1,515 @@
package fybug.nulll.pdconcurrent;
-import org.jetbrains.annotations.NotNull;
-
import java.util.function.Consumer;
-import java.util.function.Supplier;
+import java.util.function.Function;
+import fybug.nulll.pdconcurrent.e.LockType;
import fybug.nulll.pdconcurrent.fun.tryRunnable;
import fybug.nulll.pdconcurrent.fun.trySupplier;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
/**
* 并发管理.
- * 通过使用接口运行的方式隐藏内部的并发管理方法
- * 让开发人员无需管理并发的具体方式
- * {@code **read()} 方法用于申请读取方法，{@code **write()} 用于申请写入方法，只有在使用读写锁实现 {@link RWLock} 才有区别。其余实现两个之间无区别
- * {@code try**()} 类型的方法为可抛出异常的方法，可在传入的接口中抛出异常，但是需要指定异常的类型
- * 也可在该类方法中传入 catch 块和 finally 块的代码，随后将不会抛出异常。发生异常后返回将会变为 {@code null}
+ * 通过传入回调的方式隐藏内部的并发管理方法，并支持复用内部的try块，通过传入的回调插入到catch，finally块中执行
+ * {@code **lock()} 方法用于根据传入的{@link LockType}申请不同的锁类型进行执行
+ * {@code **read()} 方法用于申请使用读锁，{@code **write()} 用于申请使用写锁，只有在使用读写锁实现 {@link RWLock} 才有区别。其余实现两个之间无区别
+ * {@code try**()} 类型的方法为可抛出异常的方法，可在传入的接口中抛出异常
*
* 使用 {@code new**Lock()} 的方法获取不同并发管理的实例
*
* @author fybug
- * @version 0.0.2
+ * @version 0.1.0
+ * @apiNote 并发控制通用接口，规定并实现大部分通用控制功能
* @since PDConcurrent 0.0.1
*/
public
interface SyLock {
+ /**
+ * 使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-catch-finally块，通过三个回调参数插入不同的块中执行
+ * 所有回调均在并发域内执行
+ *
+ * @param lockType 锁类型
+ * @param run 带返回的回调
+ * @param catchby 进入catch块后的回调，传入当前异常
+ * @param finaby 进入finally块后的回调，传入前两个回调的返回值
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容
+ *
+ * @implSpec 如果有传入 {@code finaby} 回调则返回值由{@code finaby}主导，传入{@code finaby}的值根据是否发生异常传入{@code run}的返回值或{@code catchby}的返回值
+ * 任意一个回调为空时直接穿透，使用上一个正确执行的值进行传递或者返回，返回应有默认值{@code null}用于应对{@code catchby}和{@code finaby}都为空但是发生了异常的情况
+ * @see trySupplier
+ * @see Function
+ * @see LockType
+ * @since 0.1.0
+ */
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function catchby,
+ @Nullable Function finaby);
+
+ /**
+ * 使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-catch-finally块，通过三个回调参数插入不同的块中执行
+ * 所有回调均在并发域内执行
+ *
+ * @param lockType 锁类型
+ * @param run 执行的回调
+ * @param catchby 进入catch块后的回调，传入当前异常
+ * @param finaby 进入finally块后的回调
+ *
+ * @see tryRunnable
+ * @see Consumer
+ * @see Runnable
+ * @see LockType
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Consumer catchby,
+ @Nullable Runnable finaby)
+ {
+ lock(lockType, () -> {
+ run.run();
+ return null;
+ }, catchby == null ? null : e -> {
+ catchby.accept(e);
+ return null;
+ }, finaby == null ? null : _ -> {
+ finaby.run();
+ return null;
+ });
+ }
+
+ //-----------------------------------------------
- /**
- * 申请并运行于读锁
- *
- * @param run 运行代码
- */
- default
- void read(@NotNull Runnable run) {
- read(() -> {
- run.run();
- return null;
- });
- }
+ /**
+ * 使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-catch-finally块，遇到异常不处理返回{@code null}
+ *
+ * @param lockType 锁类型
+ * @param run 带返回的回调
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容，遇到异常返回{@code null}
+ *
+ * @see trySupplier
+ * @see LockType
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run) { return lock(lockType, run, null, null); }
- /**
- * 申请并运行于写锁
- *
- * @param run 运行代码
- */
- default
- void write(@NotNull Runnable run) {
- write(() -> {
- run.run();
- return null;
- });
- }
+ /**
+ * 使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-catch-finally块，遇到异常不处理
+ *
+ * @param lockType 锁类型
+ * @param run 执行的回调
+ *
+ * @see tryRunnable
+ * @see LockType
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ void lock(@NotNull LockType lockType, @NotNull tryRunnable run) {
+ lock(lockType, () -> {
+ run.run();
+ return null;
+ }, null, null);
+ }
- //------------------------------------
+ //-----------------------------------------------
- /**
- * 申请并运行于读锁
- *
- * @param run 带返回的运行代码
- *
- * @return 接口生成的数据
- */
- T read(@NotNull Supplier run);
+ /**
+ * 尝试使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-finally块，通过两个回调参数插入不同的块中执行，遇到异常会抛出
+ * 所有回调均在并发域内执行
+ *
+ * @param lockType 锁类型
+ * @param run 带返回的回调
+ * @param finaby 进入finally块后的回调，传入前一个回调的返回值，遇到异常传入{@code null}
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容，遇到异常不返回
+ *
+ * @implSpec 如果有传入 {@code finaby} 回调则返回值由{@code finaby}主导，传入{@code finaby}的值根据是否发生异常传入{@code run}的返回值或{@code null}
+ * 任意一个回调为空时直接穿透，使用上一个正确执行的值进行传递或者返回，发生异常会执行{@code finaby}但是不会返回内容
+ * @see trySupplier
+ * @see Function
+ * @see LockType
+ * @since 0.1.0
+ */
+ R trylock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function finaby) throws Exception;
- /**
- * 申请并运行于写锁
- *
- * @param run 带返回的运行代码
- *
- * @return 接口生成的数据
- */
- T write(@NotNull Supplier run);
+ /**
+ * 尝试使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-finally块，通过两个回调参数插入不同的块中执行，遇到异常会抛出
+ * 所有回调均在并发域内执行
+ *
+ * @param lockType 锁类型
+ * @param run 执行的回调
+ * @param finaby 进入finally块后的回调
+ *
+ * @see tryRunnable
+ * @see Runnable
+ * @see LockType
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ void trylock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Runnable finaby) throws Exception {
+ trylock(lockType, () -> {
+ run.run();
+ return null;
+ }, finaby == null ? null : _ -> {
+ finaby.run();
+ return null;
+ });
+ }
- //----------------------------------------------------------------------------------------------
+ //-----------------------------------------------
- /**
- * 尝试运行于读锁
- *
- * @param ecla 异常的类
- * @param run 运行代码
- */
- default
- void tryread(@NotNull Class ecla, @NotNull tryRunnable run) throws E
- {
- tryread(ecla, () -> {
- run.run();
- return null;
- });
- }
+ /**
+ * 尝试使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-finally块，遇到异常会抛出
+ *
+ * @param lockType 锁类型
+ * @param run 带返回的回调
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容，遇到异常不返回
+ *
+ * @see trySupplier
+ * @see LockType
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ R trylock(@NotNull LockType lockType, @NotNull trySupplier run) throws Exception
+ { return trylock(lockType, run, null); }
- /**
- * 尝试运行于写锁
- *
- * @param ecla 异常的类
- * @param run 运行代码
- */
- default
- void trywrite(@NotNull Class ecla, @NotNull tryRunnable run)
- throws E
- {
- trywrite(ecla, () -> {
- run.run();
- return null;
- });
- }
+ /**
+ * 尝试使用锁执行指定回调
+ *
+ * 可通过传入{@link LockType}指定锁的类型，运行时自带try-finally块，遇到异常会抛出
+ *
+ * @param lockType 锁类型
+ * @param run 执行的回调
+ *
+ * @see tryRunnable
+ * @see LockType
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ void trylock(@NotNull LockType lockType, @NotNull tryRunnable run) throws Exception {
+ trylock(lockType, () -> {
+ run.run();
+ return null;
+ }, null);
+ }
- //------------------------------------
+ /*--------------------------------------------------------------------------------------------*/
- /**
- * 尝试运行于读锁
- *
- * @param ecla 异常的类
- * @param run 带返回的运行代码
- *
- * @return 接口生成的数据
- */
- T tryread(@NotNull Class ecla, @NotNull trySupplier run)
- throws E;
+ /**
+ * 使用读锁执行指定回调
+ *
+ * 调用读锁执行，运行时自带try-catch-finally块，遇到异常不处理
+ *
+ * @param run 带返回的回调
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容
+ *
+ * @see trySupplier
+ * @see LockType#READ
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ R read(@NotNull trySupplier run) { return lock(LockType.READ, run, null, null); }
- /**
- * 尝试运行于写锁
- *
- * @param ecla 异常的类
- * @param run 带返回的运行代码
- *
- * @return 接口生成的数据
- */
- T trywrite(@NotNull Class ecla, @NotNull trySupplier run)
- throws E;
+ /**
+ * 使用读锁执行指定回调
+ *
+ * 调用读锁执行，运行时自带try-catch-finally块，遇到异常不处理
+ *
+ * @param run 执行的回调
+ *
+ * @see tryRunnable
+ * @see LockType#READ
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ void read(@NotNull tryRunnable run) {
+ lock(LockType.READ, () -> {
+ run.run();
+ return null;
+ }, null, null);
+ }
- //----------------------------------------------------------------------------------------------
+ /**
+ * 使用写锁执行指定回调
+ *
+ * 调用写锁执行，运行时自带try-catch-finally块，遇到异常不处理
+ *
+ * @param run 带返回的回调
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容
+ *
+ * @see trySupplier
+ * @see LockType#WRITE
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ R write(@NotNull trySupplier run) { return lock(LockType.WRITE, run, null, null); }
- /**
- * 尝试运行于读锁
- *
- * @param ecla 异常的类
- * @param run 运行代码
- * @param cate 异常处理代码
- *
- * @since SyLock 0.0.2
- */
- default
- void tryread(@NotNull Class ecla, @NotNull tryRunnable run,
- @NotNull Consumer cate)
- {
- tryread(ecla, () -> {
- run.run();
- return null;
- }, cate, () -> {});
- }
+ /**
+ * 使用写锁执行指定回调
+ *
+ * 调用写锁执行，运行时自带try-catch-finally块，遇到异常不处理
+ *
+ * @param run 执行的回调
+ *
+ * @see tryRunnable
+ * @see LockType#WRITE
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ void write(@NotNull tryRunnable run) {
+ lock(LockType.WRITE, () -> {
+ run.run();
+ return null;
+ }, null, null);
+ }
- /**
- * 尝试运行于写锁
- *
- * @param ecla 异常的类
- * @param run 运行代码
- * @param cate 异常处理代码
- *
- * @since SyLock 0.0.2
- */
- default
- void trywrite(@NotNull Class ecla, @NotNull tryRunnable run,
- @NotNull Consumer cate)
- {
- trywrite(ecla, () -> {
- run.run();
- return null;
- }, cate, () -> {});
- }
+ //-----------------------------------------------
- //------------------------------------
+ /**
+ * 使用读锁执行指定回调
+ *
+ * 调用读锁执行，运行时自带try-catch-finally块，通过三个回调参数插入不同的块中执行
+ * 所有回调均在并发域内执行
+ *
+ * @param run 带返回的回调
+ * @param catchby 进入catch块后的回调，传入当前异常
+ * @param finaby 进入finally块后的回调，传入前两个回调的返回值
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容
+ *
+ * @see trySupplier
+ * @see Function
+ * @see LockType#READ
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ R read(@NotNull trySupplier run, @Nullable Function catchby, @Nullable Function finaby)
+ { return lock(LockType.READ, run, catchby, finaby); }
- /**
- * 尝试运行于读锁
- *
- * @param ecla 异常的类
- * @param run 带返回的运行代码
- * @param cate 异常处理代码
- *
- * @return 接口生成的数据
- *
- * @since SyLock 0.0.2
- */
- default
- T tryread(@NotNull Class ecla, @NotNull trySupplier run,
- @NotNull Consumer cate)
- { return tryread(ecla, run, cate, () -> {}); }
+ /**
+ * 使用读锁执行指定回调
+ *
+ * 调用读锁执行，运行时自带try-catch-finally块，通过三个回调参数插入不同的块中执行
+ * 所有回调均在并发域内执行
+ *
+ * @param run 执行的回调
+ * @param catchby 进入catch块后的回调，传入当前异常
+ * @param finaby 进入finally块后的回调
+ *
+ * @see tryRunnable
+ * @see Consumer
+ * @see Runnable
+ * @see LockType#READ
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ void read(@NotNull tryRunnable run, @Nullable Consumer catchby, @Nullable Runnable finaby) {
+ lock(LockType.READ, () -> {
+ run.run();
+ return null;
+ }, catchby == null ? null : e -> {
+ catchby.accept(e);
+ return null;
+ }, finaby == null ? null : _ -> {
+ finaby.run();
+ return null;
+ });
+ }
- /**
- * 尝试运行于写锁
- *
- * @param ecla 异常的类
- * @param run 带返回的运行代码
- * @param cate 异常处理代码
- *
- * @return 接口生成的数据
- *
- * @since SyLock 0.0.2
- */
- default
- T trywrite(@NotNull Class ecla, @NotNull trySupplier run,
- @NotNull Consumer cate)
- { return trywrite(ecla, run, cate, () -> {}); }
+ /**
+ * 使用写锁执行指定回调
+ *
+ * 调用写锁执行，运行时自带try-catch-finally块，通过三个回调参数插入不同的块中执行
+ * 所有回调均在并发域内执行
+ *
+ * @param run 带返回的回调
+ * @param catchby 进入catch块后的回调，传入当前异常
+ * @param finaby 进入finally块后的回调，传入前两个回调的返回值
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容
+ *
+ * @see trySupplier
+ * @see Function
+ * @see LockType#WRITE
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ R write(@NotNull trySupplier run, @Nullable Function catchby, @Nullable Function finaby)
+ { return lock(LockType.WRITE, run, catchby, finaby); }
- //----------------------------------------------------------------------------------------------
+ /**
+ * 使用写锁执行指定回调
+ *
+ * 调用写锁执行，运行时自带try-catch-finally块，通过三个回调参数插入不同的块中执行
+ * 所有回调均在并发域内执行
+ *
+ * @param run 执行的回调
+ * @param catchby 进入catch块后的回调，传入当前异常
+ * @param finaby 进入finally块后的回调
+ *
+ * @see tryRunnable
+ * @see Consumer
+ * @see Runnable
+ * @see LockType#WRITE
+ * @see #lock(LockType, trySupplier, Function, Function)
+ * @since 0.1.0
+ */
+ default
+ void write(@NotNull tryRunnable run, @Nullable Consumer catchby, @Nullable Runnable finaby) {
+ lock(LockType.WRITE, () -> {
+ run.run();
+ return null;
+ }, catchby == null ? null : e -> {
+ catchby.accept(e);
+ return null;
+ }, finaby == null ? null : _ -> {
+ finaby.run();
+ return null;
+ });
+ }
- /**
- * 尝试运行于读锁
- *
- * @param ecla 异常的类
- * @param run 运行代码
- * @param cate 异常处理代码
- *
- * @since SyLock 0.0.2
- */
- default
- void tryread(@NotNull Class ecla, @NotNull tryRunnable run,
- @NotNull Consumer cate, @NotNull Runnable finall)
- {
- tryread(ecla, () -> {
- run.run();
- return null;
- }, cate, finall);
- }
+ //-----------------------------------------------
- /**
- * 尝试运行于写锁
- *
- * @param ecla 异常的类
- * @param run 运行代码
- * @param cate 异常处理代码
- *
- * @since SyLock 0.0.2
- */
- default
- void trywrite(@NotNull Class ecla, @NotNull tryRunnable run,
- @NotNull Consumer cate, @NotNull Runnable finall)
- {
- trywrite(ecla, () -> {
- run.run();
- return null;
- }, cate, finall);
- }
+ /**
+ * 尝试使用读锁执行指定回调
+ *
+ * 调用读锁执行，运行时自带try-finally块，遇到异常会抛出
+ *
+ * @param run 带返回的回调
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容，遇到异常不返回
+ *
+ * @see trySupplier
+ * @see LockType#READ
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ R tryread(@NotNull trySupplier run) throws Exception { return trylock(LockType.READ, run, null); }
- //------------------------------------
+ /**
+ * 尝试使用读锁执行指定回调
+ *
+ * 调用读锁执行，运行时自带try-finally块，遇到异常会抛出
+ *
+ * @param run 执行的回调
+ *
+ * @see tryRunnable
+ * @see LockType#READ
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ void tryread(@NotNull tryRunnable run) throws Exception {
+ trylock(LockType.READ, () -> {
+ run.run();
+ return null;
+ }, null);
+ }
- /**
- * 尝试运行于读锁
- *
- * @param ecla 异常的类
- * @param run 带返回的运行代码
- * @param cate 异常处理代码
- * @param finall finally 块处理代码
- *
- * @return 接口生成的数据
- *
- * @since SyLock 0.0.2
- */
- default
- T tryread(@NotNull Class ecla, @NotNull trySupplier run,
- @NotNull Consumer cate, @NotNull Runnable finall)
- {
- try {
- return tryread(ecla, run);
- } catch ( Exception e ) {
- cate.accept((E) e);
- return null;
- } finally {
- finall.run();
- }
- }
+ /**
+ * 尝试使用写锁执行指定回调
+ *
+ * 调用写锁执行，运行时自带try-finally块，遇到异常会抛出
+ *
+ * @param run 带返回的回调
+ * @param 要返回的数据类型
+ *
+ * @return 回调返回的内容，遇到异常不返回
+ *
+ * @see trySupplier
+ * @see LockType#WRITE
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ R trywrite(@NotNull trySupplier run) throws Exception { return trylock(LockType.WRITE, run, null); }
- /**
- * 尝试运行于写锁
- *
- * @param ecla 异常的类
- * @param run 带返回的运行代码
- * @param cate 异常处理代码
- * @param finall finally 块处理代码
- *
- * @return 接口生成的数据
- *
- * @since SyLock 0.0.2
- */
- default
- T trywrite(@NotNull Class ecla, @NotNull trySupplier run,
- @NotNull Consumer cate, @NotNull Runnable finall)
- {
- try {
- return trywrite(ecla, run);
- } catch ( Exception e ) {
- cate.accept((E) e);
- return null;
- } finally {
- finall.run();
- }
- }
+ /**
+ * 尝试使用写锁执行指定回调
+ *
+ * 调用写锁执行，运行时自带try-finally块，遇到异常会抛出
+ *
+ * @param run 执行的回调
+ *
+ * @see tryRunnable
+ * @see LockType#WRITE
+ * @see #trylock(LockType, trySupplier, Function)
+ * @since 0.1.0
+ */
+ default
+ void trywrite(@NotNull tryRunnable run) throws Exception {
+ trylock(LockType.WRITE, () -> {
+ run.run();
+ return null;
+ }, null);
+ }
- /*--------------------------------------------------------------------------------------------*/
+ /*--------------------------------------------------------------------------------------------*/
- /** 获取传统并发实现 */
- static @NotNull
- ObjLock newObjLock() {return new ObjLock();}
+ /**
+ * 获取传统并发实现
+ *
+ * @see ObjLock
+ */
+ @NotNull
+ static
+ ObjLock newObjLock() { return new ObjLock(); }
- /** 获取 Lock 实现 */
- static @NotNull
- ReLock newReLock() {return new ReLock();}
+ /**
+ * 获取可重入锁实现
+ *
+ * @see ReLock
+ */
+ @NotNull
+ static
+ ReLock newReLock() { return new ReLock(); }
- /** 获取读写锁实现 */
- static @NotNull
- RWLock newRWLock() {return new RWLock();}
+ /**
+ * 获取读写锁实现
+ *
+ * @see RWLock
+ */
+ @NotNull
+ static
+ RWLock newRWLock() { return new RWLock(); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/e/LockType.java b/src/main/java/fybug/nulll/pdconcurrent/e/LockType.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d722ea273db811863a73af8443091d55bac7a1b
--- /dev/null
+++ b/src/main/java/fybug/nulll/pdconcurrent/e/LockType.java
@@ -0,0 +1,18 @@
+package fybug.nulll.pdconcurrent.e;
+
+/**
+ *
锁类型.
+ *
+ * @author fybug
+ * @version 0.0.1
+ * @since PDConcurrent 0.1.0
+ */
+public
+enum LockType {
+ /** 读锁 */
+ READ,
+ /** 写锁 */
+ WRITE,
+ /** 不上锁 */
+ NOLOCK
+}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/fun/package-info.java b/src/main/java/fybug/nulll/pdconcurrent/fun/package-info.java
index 3034641e034c3d644552f82a4d71215b5d12983f..67680b723059e6f53ffc398616014843f534e497 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/fun/package-info.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/fun/package-info.java
@@ -2,7 +2,7 @@
* 功能接口包
*
* @author fybug
- * @version 0.0.2
+ * @version 0.0.4
* @since PDConcurrent 0.0.1
*/
package fybug.nulll.pdconcurrent.fun;
\ No newline at end of file
diff --git a/src/main/java/fybug/nulll/pdconcurrent/fun/tryBiConsumer.java b/src/main/java/fybug/nulll/pdconcurrent/fun/tryBiConsumer.java
deleted file mode 100644
index 291bc82d15370cbde79a4e75ec43f0621f75b4c7..0000000000000000000000000000000000000000
--- a/src/main/java/fybug/nulll/pdconcurrent/fun/tryBiConsumer.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package fybug.nulll.pdconcurrent.fun;
-import java.util.function.BiConsumer;
-
-/**
- * @author fybug
- * @version 0.0.1
- * @see BiConsumer
- * @since fun 0.0.1
- */
-@FunctionalInterface
-public
-interface tryBiConsumer {
- void accept(T t, U u) throws E;
-}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/fun/tryConsumer.java b/src/main/java/fybug/nulll/pdconcurrent/fun/tryConsumer.java
index 974937105568235ec09b754e0ba9d95071abc475..b3ba660ba278183bffead0595d8df4653ceec73d 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/fun/tryConsumer.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/fun/tryConsumer.java
@@ -1,14 +1,46 @@
package fybug.nulll.pdconcurrent.fun;
import java.util.function.Consumer;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
+
/**
* @author fybug
- * @version 0.0.1
+ * @version 0.0.2
* @see Consumer
- * @since fun 0.0.1
+ * @since fun 0.0.4
*/
-@FunctionalInterface
public
-interface tryConsumer {
- void accept(T t) throws E;
+interface tryConsumer {
+ /** @see Consumer#accept(Object) */
+ void accept(T t) throws Exception;
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryConsumer andThen(@Nullable tryRunnable after) {
+ if ( after != null ) {
+ return t -> {
+ accept(t);
+ after.run();
+ };
+ }
+ return this;
+ }
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryFunction andThen(@Nullable trySupplier after) {
+ if ( after != null ) {
+ return t -> {
+ accept(t);
+ return after.get();
+ };
+ }
+ return t -> {
+ accept(t);
+ return null;
+ };
+ }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/fun/tryFunction.java b/src/main/java/fybug/nulll/pdconcurrent/fun/tryFunction.java
index 2c515ad40737dce4375bf5e829403201c63f000a..060841ce89b8f0d01861fc8ba388be747cfa72c3 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/fun/tryFunction.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/fun/tryFunction.java
@@ -1,14 +1,35 @@
package fybug.nulll.pdconcurrent.fun;
import java.util.function.Function;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
+
/**
* @author fybug
- * @version 0.0.1
+ * @version 0.0.2
* @see Function
- * @since fun 0.0.1
+ * @since fun 0.0.4
*/
-@FunctionalInterface
public
-interface tryFunction {
- R apply(T t) throws E;
+interface tryFunction {
+ /** @see Function#apply(Object) */
+ R apply(T t) throws Exception;
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryConsumer andThen(@Nullable tryConsumer after) {
+ if ( after != null )
+ return t -> after.accept(apply(t));
+ return this::apply;
+ }
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryFunction andThen(@Nullable tryFunction after) {
+ if ( after != null )
+ return t -> after.apply(apply(t));
+ return (tryFunction) this;
+ }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/fun/tryRunnable.java b/src/main/java/fybug/nulll/pdconcurrent/fun/tryRunnable.java
index c5ae5eaef15d53c848e558191a7223da63646d8b..970eeacf5601ed361df08aaee1baf8d42b88b7aa 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/fun/tryRunnable.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/fun/tryRunnable.java
@@ -1,13 +1,74 @@
package fybug.nulll.pdconcurrent.fun;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
/**
* @author fybug
- * @version 0.0.1
+ * @version 0.0.2
* @see Runnable
- * @since fun 0.0.2
+ * @since fun 0.0.4
*/
@FunctionalInterface
public
-interface tryRunnable {
- void run() throws E;
+interface tryRunnable {
+ /** @see Runnable#run() */
+ void run() throws Exception;
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryRunnable andThen(@Nullable tryRunnable after) {
+ if ( after != null ) {
+ return () -> {
+ run();
+ after.run();
+ };
+ }
+ return this;
+ }
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ trySupplier andThen(@Nullable trySupplier after) {
+ if ( after != null ) {
+ return () -> {
+ run();
+ return after.get();
+ };
+ }
+ return () -> {
+ run();
+ return null;
+ };
+ }
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryRunnable andThen(@Nullable tryConsumer after) {
+ if ( after != null ) {
+ return () -> {
+ run();
+ after.accept(null);
+ };
+ }
+ return this;
+ }
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ trySupplier andThen(@Nullable tryFunction after) {
+ if ( after != null ) {
+ return () -> {
+ run();
+ return after.apply(null);
+ };
+ }
+ return () -> {
+ run();
+ return null;
+ };
+ }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/fun/trySupplier.java b/src/main/java/fybug/nulll/pdconcurrent/fun/trySupplier.java
index 81a193b6b08aa07ef5a2f2d28c469c7dcae02a52..1733f2485bd31b2c96721e0e41b24884ce8e2821 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/fun/trySupplier.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/fun/trySupplier.java
@@ -1,14 +1,36 @@
package fybug.nulll.pdconcurrent.fun;
import java.util.function.Supplier;
+import jakarta.annotation.Nullable;
+import jakarta.validation.constraints.NotNull;
+
/**
* @author fybug
- * @version 0.0.1
+ * @version 0.0.2
* @see Supplier
- * @since fun 0.0.1
+ * @since fun 0.0.4
*/
@FunctionalInterface
public
-interface trySupplier {
- V get() throws E;
+interface trySupplier {
+ /** @see Supplier#get() */
+ R get() throws Exception;
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ tryRunnable andThen(@Nullable tryConsumer after) {
+ if ( after != null )
+ return () -> after.accept(get());
+ return this::get;
+ }
+
+ /** @since 0.0.2 */
+ @NotNull
+ default
+ trySupplier andThen(@Nullable tryFunction after) {
+ if ( after != null )
+ return () -> after.apply(get());
+ return (trySupplier) this;
+ }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/package-info.java b/src/main/java/fybug/nulll/pdconcurrent/package-info.java
index dbe9cc79f8fe3208c95c2c7b6da6e26878098aa3..640060ae19b852a6dc78aafd430b0b72bef8dd31 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/package-info.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/package-info.java
@@ -1,11 +1,11 @@
/**
* 并发管理工具.
- * 用于并发管理的工具，使用接口在并发域中执行代码。
- * 根据实现的不同并发管理也不同，但都实现 {@link fybug.nulll.pdconcurrent.SyLock} 接口
- * 附带 {@code try***} 的功能接口包，在 java 原有的功能接口的基础上允许抛出异常
+ * 用于并发管理的工具，使用回调在并发域中执行代码。
+ * 根据实现的不同并发管理也不同，但都实现{@link fybug.nulll.pdconcurrent.SyLock}接口
+ * 附带{@code try***}的功能接口包{@link fybug.nulll.pdconcurrent.fun}，在java原有的功能接口的基础上允许抛出异常
*
* @author fybug
- * @version 0.0.1
- * @since JDK 13+
+ * @version 0.1.0
+ * @since JDK 23+
*/
package fybug.nulll.pdconcurrent;
\ No newline at end of file