c) { this.defaultLockThreadContext = c; }
+
+ /**
+ * 锁运行具体实现
+ *
+ * {@link #lock(LockType, trySupplier, Function)}与{@link #lock(LockType, trySupplier, Function, Function)}底层实现,要求同时覆盖两个接口的规范,同时应该支持上下文参数{@link LockThreadContext}
+ * 通过{@code catchby}传入的值决定异常的处理
+ *
+ * @param lockType 锁类型
+ * @param run 带返回的回调
+ * @param catchby 进入catch块后的回调,传入当前异常,如果需要无视并不抛出异常则传入{@code null}
+ * @param finaby 进入finally块后的回调,传入前一个回调的返回值,遇到异常传入{@code null}
+ * @param 要返回的数据类型
+ * @param 运行时异常类型
+ *
+ * @return 回调返回的内容,中途二次抛出异常时不返回
+ *
+ * @throws E1 二次抛出的异常类型
+ * @implSpec {@code catchby}传入为{@code null}时应该无视并不抛出异常,同时给{@code finaby}的值为{@code null}
+ */
+ abstract protected
+ R lockimpl(@NotNull LockType lockType, @NotNull trySupplier run,
+ @Nullable tryFunction catchby,
+ @Nullable Function finaby) throws E1;
+
+ /**
+ * 尝试上锁运行具体实现
+ *
+ * {@link #trylock(LockType, tryFunction, Function)}与{@link #trylock(LockType, tryFunction, Function, Function)}底层实现,要求同时覆盖两个接口的规范,同时应该支持上下文参数{@link LockThreadContext}
+ * 通过{@code catchby}传入的值决定异常的处理
+ *
+ * @param lockType 锁类型
+ * @param run 带返回的回调,传入参数是否获取到锁
+ * @param catchby 进入catch块后的回调,传入当前异常,如果需要无视并不抛出异常则传入{@code null}
+ * @param finaby 进入finally块后的回调,传入前一个回调的返回值,遇到异常传入{@code null}
+ * @param 要返回的数据类型
+ * @param 运行时异常类型
+ *
+ * @return 回调返回的内容,中途二次抛出异常时不返回
+ *
+ * @throws E1 二次抛出的异常类型
+ * @implSpec {@code catchby}传入为{@code null}时应该无视并不抛出异常,同时给{@code finaby}的值为{@code null}
+ */
+ abstract protected
+ R trylockimpl(@NotNull LockType lockType,
+ @NotNull tryFunction run,
+ @Nullable tryFunction catchby,
+ @Nullable Function finaby) throws E1;
+
/**
* {@inheritDoc}
*
@@ -26,38 +88,17 @@ class AbstractSyLock implements SyLock {
* @param catchby {@inheritDoc}
* @param finaby {@inheritDoc}
* @param {@inheritDoc}
+ * @param {@inheritDoc}
*
* @return {@inheritDoc}
*
- * @implNote 使用 {@link #lock(LockType)} 与 {@link #unlock()} 方法实现上锁与解锁
+ * @see #lockimpl(LockType, trySupplier, tryFunction, Function)
*/
@Override
public
- R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function catchby,
- @Nullable Function finaby)
- {
- R o = null;
- // 防止finally内的回调抛异常
- try {
- try {
- // 上锁
- lock(lockType);
- // 主要内容
- o = run.get();
- } catch ( Exception e ) {
- // 异常处理
- if ( catchby != null )
- o = catchby.apply(e);
- } finally {
- // 收尾
- if ( finaby != null )
- o = finaby.apply(o);
- }
- } finally {
- unlock();
- }
- return o;
- }
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run,
+ @Nullable Function catchby, @Nullable Function finaby)
+ { return lockimpl(lockType, run, catchby == null ? null : catchby::apply, finaby); }
/**
* {@inheritDoc}
@@ -66,32 +107,18 @@ class AbstractSyLock implements SyLock {
* @param run {@inheritDoc}
* @param finaby {@inheritDoc}
* @param {@inheritDoc}
+ * @param {@inheritDoc}
*
* @return {@inheritDoc}
*
- * @implNote 使用 {@link #lock(LockType)} 与 {@link #unlock()} 方法实现上锁与解锁
+ * @throws E {@inheritDoc}
+ * @see #lockimpl(LockType, trySupplier, tryFunction, Function)
*/
@Override
public
- R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function finaby) throws Exception {
- R o = null;
- // 防止finally内的回调抛异常
- try {
- try {
- // 上锁
- lock(lockType);
- // 主要内容
- o = run.get();
- } finally {
- // 收尾
- if ( finaby != null )
- o = finaby.apply(o);
- }
- } finally {
- unlock();
- }
- return o;
- }
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run,
+ @Nullable Function finaby) throws E
+ { return lockimpl(lockType, run, e -> { throw e; }, finaby); }
/**
* {@inheritDoc}
@@ -101,36 +128,17 @@ class AbstractSyLock implements SyLock {
* @param catchby {@inheritDoc}
* @param finaby {@inheritDoc}
* @param {@inheritDoc}
+ * @param {@inheritDoc}
*
* @return {@inheritDoc}
*
- * @implNote 使用 {@link #trylock(LockType)} 与 {@link #unlock()} 方法实现上锁与解锁
+ * @see #trylockimpl(LockType, tryFunction, tryFunction, Function)
*/
@Override
public
- R trylock(@NotNull LockType lockType, @NotNull tryFunction run, @Nullable Function catchby,
- @Nullable Function finaby)
- {
- R o = null;
- // 防止finally内的回调抛异常
- try {
- try {
- // 上锁
- o = run.apply(trylock(lockType));
- } catch ( Exception e ) {
- // 异常处理
- if ( catchby != null )
- o = catchby.apply(e);
- } finally {
- // 收尾
- if ( finaby != null )
- o = finaby.apply(o);
- }
- } finally {
- unlock();
- }
- return o;
- }
+ R trylock(@NotNull LockType lockType, @NotNull tryFunction run,
+ @Nullable Function catchby, @Nullable Function finaby)
+ { return trylockimpl(lockType, run, catchby == null ? null : catchby::apply, finaby); }
/**
* {@inheritDoc}
@@ -139,78 +147,121 @@ class AbstractSyLock implements SyLock {
* @param run {@inheritDoc}
* @param finaby {@inheritDoc}
* @param {@inheritDoc}
+ * @param {@inheritDoc}
*
* @return {@inheritDoc}
*
- * @throws Exception {@inheritDoc}
- * @implNote 使用 {@link #trylock(LockType)} 与 {@link #unlock()} 方法实现上锁与解锁
+ * @throws E {@inheritDoc}
+ * @see #trylockimpl(LockType, tryFunction, tryFunction, Function)
*/
@Override
public
- R trylock(@NotNull LockType lockType, @NotNull tryFunction run, @Nullable Function finaby)
- throws Exception
- {
- R o = null;
- // 防止finally内的回调抛异常
- try {
- try {
- // 上锁
- o = run.apply(trylock(lockType));
- } finally {
- // 收尾
- if ( finaby != null )
- o = finaby.apply(o);
- }
- } finally {
- unlock();
- }
- return o;
- }
+ R trylock(@NotNull LockType lockType, @NotNull tryFunction run,
+ @Nullable Function finaby) throws E
+ { return trylockimpl(lockType, run, e -> { throw e; }, finaby); }
/**
- * 上锁函数
+ * 更新默认锁上下文参数
+ *
+ * 该方法是非线程安全的,因为每次执行前都会先保存默认参数的引用,更新时应该传入一个新的参数对象,至少不能是同一个对象
*
- * @param lockType 锁类型
- *
- * @throws Exception 可能抛出的异常
- * @implSpec 在此处实现上锁功能
+ * @param lockThreadContext 新的默认上下文参数
*/
- protected abstract
- void lock(@NotNull LockType lockType) throws Exception;
+ public
+ void setDefaultLockThreadContext(@NotNull LockThreadContext lockThreadContext) {
+ this.defaultLockThreadContext = lockThreadContext;
+ }
+
+ /** 获取当前默认上下文参数 */
+ @NotNull
+ public
+ LockThreadContext defaultLockThreadContext() { return defaultLockThreadContext; }
/**
- * 尝试上锁函数
- *
- * @param lockType 锁类型
- *
- * @return 是否成功上锁
- *
- * @implSpec 在此处实现尝试上锁功能
+ * 获取当前线程的上下文参数
+ *
+ * 如果没有设置独立的上下文参数,则使用{@link #defaultLockThreadContext}
*/
- protected abstract
- boolean trylock(@NotNull LockType lockType);
+ @NotNull
+ public
+ LockThreadContext getLockThreadContext() {
+ var c = lockThreadContext.get();
+ if ( c == null )
+ return defaultLockThreadContext;
+ return c;
+ }
/**
- * 解锁函数
- *
- * @implSpec 在此处实现解锁功能,解锁的类型按照最后上锁的类型处理
+ * 设置当前线程上下文参数
+ *
+ * 要求不在锁内使用,否则可能会出现异常
*/
- public abstract
- void unlock();
+ public
+ void setLockThreadContext(@NotNull LockThreadContext c) { lockThreadContext.set(c); }
+
+ /**
+ * 移除当前上下文参数
+ *
+ * 通常情况下执行结束后会自动移除,但如果手动设置后并没有执行锁的情况下才需要手动移除
+ */
+ public
+ void removeLockThreadContext() { lockThreadContext.remove(); }
/**
- * 检查锁是否被占用
+ *
当前线程的锁上下文.
+ * 根据该参数可以改变使用的锁对象,更改当前对象支持的上锁方式,与参数上锁的超时时间等
+ * 参数上锁时间为{@code null}时为不使用带超时功能的参数上锁
+ *
+ * @param 用于上锁的对象
*
- * @return 是否被占用
+ * @author fybug
+ * @version 0.0.1
+ * @since AbstractSyLock 0.0.1
*/
- public abstract
- boolean isLocked();
+ public static
+ class LockThreadContext {
+ /** 本次锁对象 */
+ @Setter @Getter @NotNull protected T lock;
+ /**
+ * 是否支持线程中断
+ *
+ * @see InterruptedException
+ */
+ @Setter @Getter protected boolean interruptiblyLock;
+ /**
+ * 尝试锁时间限制
+ *
+ * 传入为{@code null}时为不使用超时功能
+ *
+ * @see InterruptedException
+ */
+ @Setter @Getter @Nullable protected Time tryTimeout;
+
+ public
+ LockThreadContext(@NotNull T lock, boolean interruptiblyLock, @Nullable Time tryTimeout) {
+ this.lock = lock;
+ this.interruptiblyLock = interruptiblyLock;
+ this.tryTimeout = tryTimeout;
+ }
+ }
/**
- * 检查当前线程是否持有锁
+ *
时间对象.
+ * 用于记录时间,支持设置时间类型
*
- * @return 当前线程是否持有锁
+ * @author fybug
+ * @version 0.0.1
+ * @since AbstractSyLock 0.0.1
*/
- public abstract
- boolean isLockedCurrentThread();
+ public static
+ class Time {
+ @Getter protected long timeout;
+ @Getter @NotNull protected TimeUnit unit;
+
+ public
+ Time(long timeout, @NotNull TimeUnit unit) {
+ this.timeout = timeout;
+ this.unit = unit;
+ }
+ }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/Lock.java b/src/main/java/fybug/nulll/pdconcurrent/i/Lock.java
index de52725a072334de92ced7e77c6df3fa28550abc..0ab3c2463bd8e40ee2b5dd2e5a39c2d7024b9853 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/Lock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/Lock.java
@@ -1,10 +1,8 @@
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.pdutilfunctionexpand.trySupplier;
import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
@@ -32,35 +30,15 @@ interface Lock {
* @param catchby 进入catch块后的回调,传入当前异常
* @param finaby 进入finally块后的回调,传入前两个回调的返回值
* @param 要返回的数据类型
+ * @param 运行时异常类型
*
* @return 回调返回的内容
*
* @implSpec 如果有传入 {@code finaby} 回调则返回值由{@code finaby}主导,传入{@code finaby}的值根据是否发生异常传入{@code run}的返回值或{@code catchby}的返回值
* 任意一个回调为空时直接穿透,使用上一个正确执行的值进行传递或者返回,传递值应默认为{@code null}用于应对{@code catchby}和{@code finaby}都为空但是发生了异常的情况
*/
- R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function catchby,
- @Nullable Function finaby);
-
- /**
- * 使用锁执行指定回调
- *
- * {@link #lock(LockType, trySupplier, Function, Function)}的无返回变体
- */
- 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;
- });
- }
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run,
+ @Nullable Function catchby, @Nullable Function finaby);
/**
* 使用锁执行指定回调
@@ -72,28 +50,14 @@ interface Lock {
* @param run 带返回的回调
* @param finaby 进入finally块后的回调,传入前一个回调的返回值,遇到异常传入{@code null}
* @param 要返回的数据类型
+ * @param 运行时异常类型
*
* @return 回调返回的内容,遇到异常不返回
*
- * @throws Exception 异常类型根据实际运行时回调抛出决定
+ * @throws E 异常类型根据实际运行时回调抛出决定
* @implSpec 如果有传入 {@code finaby} 回调则返回值由{@code finaby}主导,传入{@code finaby}的值根据是否发生异常传入{@code run}的返回值或{@code null}
* 任意一个回调为空时直接穿透,使用上一个正确执行的值进行传递或者返回,发生异常会执行{@code finaby}但是不会返回内容
*/
- R lock(@NotNull LockType lockType, @NotNull trySupplier run, @Nullable Function finaby) throws Exception;
-
- /**
- * 使用锁执行指定回调
- *
- * {@link #lock(LockType, trySupplier, Function)}的无返回变体
- */
- default
- void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Runnable finaby) throws Exception {
- lock(lockType, () -> {
- run.run();
- return null;
- }, finaby == null ? null : _ -> {
- finaby.run();
- return null;
- });
- }
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run,
+ @Nullable Function finaby) throws E;
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/ReadLock.java b/src/main/java/fybug/nulll/pdconcurrent/i/ReadLock.java
index 1824694a640efd5a1b72e203c6109089eabd0b9f..53943245e61ad426b045ed6c12727bbb7057ff8a 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/ReadLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/ReadLock.java
@@ -1,11 +1,9 @@
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 fybug.nulll.pdutilfunctionexpand.trySupplier;
import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
@@ -28,33 +26,16 @@ interface ReadLock extends LockSimple {
* {@link #lock(LockType, trySupplier, Function, Function)}指定读锁的变种
*/
default
- R read(@NotNull trySupplier run, @Nullable Function catchby, @Nullable Function finaby)
+ R read(@NotNull trySupplier run, @Nullable Function catchby,
+ @Nullable Function finaby)
{ return lock(LockType.READ, run, catchby, finaby); }
- /**
- * 使用读锁执行指定回调
- *
- * {@link #lock(LockType, tryRunnable, Consumer, Runnable)}指定读锁的变种
- */
- default
- void read(@NotNull tryRunnable run, @Nullable Consumer catchby, @Nullable Runnable finaby)
- { lock(LockType.READ, run, catchby, finaby); }
-
/**
* 使用读锁执行指定回调
*
* {@link #lock(LockType, trySupplier, Function)}指定读锁的变种
*/
default
- R read(@NotNull trySupplier run, @Nullable Function finaby) throws Exception
+ R read(@NotNull trySupplier run, @Nullable Function finaby) throws E
{ return lock(LockType.READ, run, finaby); }
-
- /**
- * 使用读锁执行指定回调
- *
- * {@link #lock(LockType, tryRunnable, Runnable)}指定读锁的变种
- */
- default
- void read(@NotNull tryRunnable run, @Nullable Runnable finaby) throws Exception
- { lock(LockType.READ, run, finaby); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/TryLock.java b/src/main/java/fybug/nulll/pdconcurrent/i/TryLock.java
index 73c60439b441914f200db03fcd56c62d1d341a51..c49cd174e95320b64e43dd552426b661348e4cab 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/TryLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/TryLock.java
@@ -1,11 +1,9 @@
package fybug.nulll.pdconcurrent.i;
import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Consumer;
import java.util.function.Function;
import fybug.nulll.pdconcurrent.e.LockType;
-import fybug.nulll.pdconcurrent.fun.tryConsumer;
-import fybug.nulll.pdconcurrent.fun.tryFunction;
+import fybug.nulll.pdutilfunctionexpand.tryFunction;
import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
@@ -31,6 +29,7 @@ interface TryLock {
* @param catchby 进入catch块后的回调,传入当前异常
* @param finaby 进入finally块后的回调,传入前两个回调的返回值
* @param 要返回的数据类型
+ * @param 运行时异常类型
*
* @return 回调返回的内容
*
@@ -38,29 +37,8 @@ interface TryLock {
* 如果有传入 {@code finaby} 回调则返回值由{@code finaby}主导,传入{@code finaby}的值根据是否发生异常传入{@code run}的返回值或{@code catchby}的返回值
* 任意一个回调为空时直接穿透,使用上一个正确执行的值进行传递或者返回,传递值应默认为{@code null}用于应对{@code catchby}和{@code finaby}都为空但是发生了异常的情况
*/
- R trylock(@NotNull LockType lockType, @NotNull tryFunction run, @Nullable Function catchby,
- @Nullable Function finaby);
-
- /**
- * 尝试使用锁执行指定回调
- *
- * {@link #trylock(LockType, tryFunction, Function, Function)}的无返回变体
- */
- default
- void trylock(@NotNull LockType lockType, @NotNull tryConsumer run, @Nullable Consumer catchby,
- @Nullable Runnable finaby)
- {
- trylock(lockType, b -> {
- run.accept(b);
- return null;
- }, catchby == null ? null : e -> {
- catchby.accept(e);
- return null;
- }, finaby == null ? null : _ -> {
- finaby.run();
- return null;
- });
- }
+ R trylock(@NotNull LockType lockType, @NotNull tryFunction run,
+ @Nullable Function catchby, @Nullable Function finaby);
/**
* 尝试使用锁执行指定回调
@@ -72,30 +50,15 @@ interface TryLock {
* @param run 带返回的回调,传入参数是否获取到锁
* @param finaby 进入finally块后的回调,传入前两个回调的返回值,遇到异常传入{@code null}
* @param 要返回的数据类型
+ * @param 运行时异常类型
*
* @return 回调返回的内容,遇到异常不返回
*
- * @throws Exception 异常类型根据实际运行时回调抛出决定
+ * @throws E 异常类型根据实际运行时回调抛出决定
* @implSpec 该方法实现时应尽量使用如 {@link ReentrantLock#tryLock()} 之类的方法获取锁,并将是否成功获取传入{@code run}回调中
* 如果有传入 {@code finaby} 回调则返回值由{@code finaby}主导,传入{@code finaby}的值根据是否发生异常传入{@code run}的返回值或{@code catchby}的返回值
* 任意一个回调为空时直接穿透,使用上一个正确执行的值进行传递或者返回,传递值应默认为{@code null}用于应对{@code catchby}和{@code finaby}都为空但是发生了异常的情况
*/
- R trylock(@NotNull LockType lockType, @NotNull tryFunction run, @Nullable Function finaby)
- throws Exception;
-
- /**
- * 尝试使用锁执行指定回调
- *
- * {@link #trylock(LockType, tryFunction, Function)}的无返回变体
- */
- default
- void trylock(@NotNull LockType lockType, @NotNull tryConsumer run, @Nullable Runnable finaby) throws Exception {
- trylock(lockType, b -> {
- run.accept(b);
- return null;
- }, finaby == null ? null : _ -> {
- finaby.run();
- return null;
- });
- }
+ R trylock(@NotNull LockType lockType, @NotNull tryFunction run,
+ @Nullable Function finaby) throws E;
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/TryReadLock.java b/src/main/java/fybug/nulll/pdconcurrent/i/TryReadLock.java
index 2f8b22dc016ecdfc6cbb4a6fc7789a1c579cbfe0..33de1877a7acdaf86ea3bc6f2b3158bc79053b56 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/TryReadLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/TryReadLock.java
@@ -1,11 +1,9 @@
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.tryConsumer;
-import fybug.nulll.pdconcurrent.fun.tryFunction;
import fybug.nulll.pdconcurrent.i.simple.TryLockSimple;
+import fybug.nulll.pdutilfunctionexpand.tryFunction;
import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
@@ -28,34 +26,16 @@ interface TryReadLock extends TryLockSimple {
* {@link #trylock(LockType, tryFunction, Function, Function)}指定读锁的变种
*/
default
- R tryread(@NotNull tryFunction run, @Nullable Function catchby,
- @Nullable Function finaby)
+ R tryread(@NotNull tryFunction run, @Nullable Function catchby,
+ @Nullable Function finaby)
{ return trylock(LockType.READ, run, catchby, finaby); }
- /**
- * 尝试使用读锁执行指定回调
- *
- * {@link #trylock(LockType, tryConsumer, Consumer, Runnable)}指定读锁的变种
- */
- default
- void tryread(@NotNull tryConsumer run, @Nullable Consumer catchby, @Nullable Runnable finaby)
- { trylock(LockType.READ, run, catchby, finaby); }
-
/**
* 尝试使用读锁执行指定回调
*
* {@link #trylock(LockType, tryFunction, Function)}指定读锁的变种
*/
default
- R tryread(@NotNull tryFunction run, @Nullable Function finaby) throws Exception
+ R tryread(@NotNull tryFunction run, @Nullable Function finaby) throws E
{ return trylock(LockType.READ, run, finaby); }
-
- /**
- * 尝试使用读锁执行指定回调
- *
- * {@link #trylock(LockType, tryConsumer, Runnable)}指定读锁的变种
- */
- default
- void tryread(@NotNull tryConsumer run, @Nullable Runnable finaby) throws Exception
- { trylock(LockType.READ, run, finaby); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/TryWriteLock.java b/src/main/java/fybug/nulll/pdconcurrent/i/TryWriteLock.java
index 75f55b7900ae4794972e589240b582618bea8516..45002f54259a075c3322fd3a23e0eaf4e5dfb45b 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/TryWriteLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/TryWriteLock.java
@@ -1,11 +1,9 @@
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.tryConsumer;
-import fybug.nulll.pdconcurrent.fun.tryFunction;
import fybug.nulll.pdconcurrent.i.simple.TryLockSimple;
+import fybug.nulll.pdutilfunctionexpand.tryFunction;
import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
@@ -28,34 +26,16 @@ interface TryWriteLock extends TryLockSimple {
* {@link #trylock(LockType, tryFunction, Function, Function)}指定写锁的变种
*/
default
- R trywrite(@NotNull tryFunction run, @Nullable Function catchby,
- @Nullable Function finaby)
+ R trywrite(@NotNull tryFunction run, @Nullable Function catchby,
+ @Nullable Function finaby)
{ return trylock(LockType.WRITE, run, catchby, finaby); }
- /**
- * 尝试使用写锁执行指定回调
- *
- * {@link #trylock(LockType, tryConsumer, Consumer, Runnable)}指定写锁的变种
- */
- default
- void trywrite(@NotNull tryConsumer run, @Nullable Consumer catchby, @Nullable Runnable finaby)
- { trylock(LockType.WRITE, run, catchby, finaby); }
-
/**
* 尝试使用写锁执行指定回调
*
* {@link #trylock(LockType, tryFunction, Function)}指定写锁的变种
*/
default
- R trywrite(@NotNull tryFunction run, @Nullable Function finaby) throws Exception
+ R trywrite(@NotNull tryFunction run, @Nullable Function finaby) throws E
{ return trylock(LockType.WRITE, run, finaby); }
-
- /**
- * 尝试使用写锁执行指定回调
- *
- * {@link #trylock(LockType, tryConsumer, Runnable)}指定写锁的变种
- */
- default
- void trywrite(@NotNull tryConsumer run, @Nullable Runnable finaby) throws Exception
- { trylock(LockType.WRITE, run, finaby); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/WriteLock.java b/src/main/java/fybug/nulll/pdconcurrent/i/WriteLock.java
index 5b6f57479f27a0b2a887e632ddfd94c92d8893e4..5021880e7dbe6b5a93a7ce6772ce498c9774079f 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/WriteLock.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/WriteLock.java
@@ -1,11 +1,9 @@
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 fybug.nulll.pdutilfunctionexpand.trySupplier;
import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
@@ -28,33 +26,16 @@ interface WriteLock extends LockSimple {
* {@link #lock(LockType, trySupplier, Function, Function)}指定写锁的变种
*/
default
- R write(@NotNull trySupplier run, @Nullable Function catchby, @Nullable Function finaby)
+ R write(@NotNull trySupplier run, @Nullable Function catchby,
+ @Nullable Function finaby)
{ return lock(LockType.WRITE, run, catchby, finaby); }
- /**
- * 使用写锁执行指定回调
- *
- * {@link #lock(LockType, tryRunnable, Consumer, Runnable)}指定写锁的变种
- */
- default
- void write(@NotNull tryRunnable run, @Nullable Consumer catchby, @Nullable Runnable finaby)
- { lock(LockType.WRITE, run, catchby, finaby); }
-
/**
* 使用写锁执行指定回调
*
* {@link #lock(LockType, trySupplier, Function)}指定写锁的变种
*/
default
- R write(@NotNull trySupplier run, @Nullable Function finaby) throws Exception
+ R write(@NotNull trySupplier run, @Nullable Function finaby) throws E
{ return lock(LockType.WRITE, run, finaby); }
-
- /**
- * 使用写锁执行指定回调
- *
- * {@link #lock(LockType, tryRunnable, Runnable)}指定写锁的变种
- */
- default
- void write(@NotNull tryRunnable run, @Nullable Runnable finaby) throws Exception
- { lock(LockType.WRITE, run, finaby); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/package-info.java b/src/main/java/fybug/nulll/pdconcurrent/i/package-info.java
index 04495588a4792675defc03937e02c2f636fa6f77..6e502979bea6172e9f3a79d9e78db50cb8a94e3a 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/package-info.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/package-info.java
@@ -3,7 +3,7 @@
* 提供基础功能接口与部分功能框架实现
*
* @author fybug
- * @version 0.0.2
+ * @version 0.0.3
* @since PDConcurrent 0.1.2
*/
package fybug.nulll.pdconcurrent.i;
\ No newline at end of file
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/simple/LockSimple.java b/src/main/java/fybug/nulll/pdconcurrent/i/simple/LockSimple.java
index 639d29128f3d0768b76afeb68331e77e4510d902..8d8dbcaa21538bfb1d1dc2d142937984e1ae159c 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/simple/LockSimple.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/simple/LockSimple.java
@@ -1,10 +1,12 @@
package fybug.nulll.pdconcurrent.i.simple;
+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.Lock;
+import fybug.nulll.pdutilfunctionexpand.tryRunnable;
+import fybug.nulll.pdutilfunctionexpand.trySupplier;
+import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
/**
@@ -16,13 +18,52 @@ import jakarta.validation.constraints.NotNull;
*/
public
interface LockSimple extends Lock {
+ /**
+ * 使用锁执行指定回调
+ *
+ * {@link #lock(LockType, trySupplier, Function, Function)}的无返回变体
+ */
+ 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 e) -> {
+ catchby.accept(e);
+ return null;
+ }, finaby == null ? null : _ -> {
+ finaby.run();
+ return null;
+ });
+ }
+
+ /**
+ * 使用锁执行指定回调
+ *
+ * {@link #lock(LockType, trySupplier, Function)}的无返回变体
+ */
+ default
+ void lock(@NotNull LockType lockType, @NotNull tryRunnable run, @Nullable Runnable finaby)
+ throws E
+ {
+ lock(lockType, () -> {
+ run.run();
+ return null;
+ }, finaby == null ? null : _ -> {
+ finaby.run();
+ return null;
+ });
+ }
+
/**
* 使用锁执行指定回调
*
* {@link #lock(LockType, trySupplier, Function)}的简易变体
*/
default
- R lock(@NotNull LockType lockType, @NotNull trySupplier run) throws Exception
+ R lock(@NotNull LockType lockType, @NotNull trySupplier run) throws E
{ return lock(lockType, run, null); }
/**
@@ -31,6 +72,6 @@ interface LockSimple extends Lock {
* {@link #lock(LockType, tryRunnable, Runnable)}的简易变体
*/
default
- void lock(@NotNull LockType lockType, @NotNull tryRunnable run) throws Exception
+ void lock(@NotNull LockType lockType, @NotNull tryRunnable run) throws E
{ lock(lockType, run, null); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/simple/ReadLockSimple.java b/src/main/java/fybug/nulll/pdconcurrent/i/simple/ReadLockSimple.java
index 8515240bb3d6d1b4a02e49dc173c987cd3d1fa37..49aa85a102dc5c25753a4e648acde2328d23f087 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/simple/ReadLockSimple.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/simple/ReadLockSimple.java
@@ -1,8 +1,11 @@
package fybug.nulll.pdconcurrent.i.simple;
+import java.util.function.Consumer;
+
import fybug.nulll.pdconcurrent.e.LockType;
-import fybug.nulll.pdconcurrent.fun.tryRunnable;
-import fybug.nulll.pdconcurrent.fun.trySupplier;
import fybug.nulll.pdconcurrent.i.ReadLock;
+import fybug.nulll.pdutilfunctionexpand.tryRunnable;
+import fybug.nulll.pdutilfunctionexpand.trySupplier;
+import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
/**
@@ -15,13 +18,31 @@ import jakarta.validation.constraints.NotNull;
@SuppressWarnings("unused")
public
interface ReadLockSimple extends ReadLock {
+ /**
+ * 使用读锁执行指定回调
+ *
+ * {@link #lock(LockType, tryRunnable, Consumer, Runnable)}指定读锁的变种
+ */
+ default
+ void read(@NotNull tryRunnable run, @Nullable Consumer catchby, @Nullable Runnable finaby)
+ { lock(LockType.READ, run, catchby, finaby); }
+
+ /**
+ * 使用读锁执行指定回调
+ *
+ * {@link #lock(LockType, tryRunnable, Runnable)}指定读锁的变种
+ */
+ default
+ void read(@NotNull tryRunnable run, @Nullable Runnable finaby) throws E
+ { lock(LockType.READ, run, finaby); }
+
/**
* 使用读锁执行指定回调
*
* {@link #lock(LockType, trySupplier)}指定读锁的变种
*/
default
- R read(@NotNull trySupplier run) throws Exception
+ R read(@NotNull trySupplier run) throws E
{ return lock(LockType.READ, run); }
/**
@@ -30,6 +51,6 @@ interface ReadLockSimple extends ReadLock {
* {@link #lock(LockType, tryRunnable)}指定读锁的变种
*/
default
- void read(@NotNull tryRunnable run) throws Exception
+ void read(@NotNull tryRunnable run) throws E
{ lock(LockType.READ, run); }
}
diff --git a/src/main/java/fybug/nulll/pdconcurrent/i/simple/TryLockSimple.java b/src/main/java/fybug/nulll/pdconcurrent/i/simple/TryLockSimple.java
index 8e8976a9ebeeb6629fa9304703166a2ffaec369d..0e1e5235af495d095a7452c8d9911b12b87e82fa 100644
--- a/src/main/java/fybug/nulll/pdconcurrent/i/simple/TryLockSimple.java
+++ b/src/main/java/fybug/nulll/pdconcurrent/i/simple/TryLockSimple.java
@@ -1,10 +1,12 @@
package fybug.nulll.pdconcurrent.i.simple;
+import java.util.function.Consumer;
import java.util.function.Function;
import fybug.nulll.pdconcurrent.e.LockType;
-import fybug.nulll.pdconcurrent.fun.tryConsumer;
-import fybug.nulll.pdconcurrent.fun.tryFunction;
import fybug.nulll.pdconcurrent.i.TryLock;
+import fybug.nulll.pdutilfunctionexpand.tryConsumer;
+import fybug.nulll.pdutilfunctionexpand.tryFunction;
+import jakarta.annotation.Nullable;
import jakarta.validation.constraints.NotNull;
/**
@@ -16,13 +18,52 @@ import jakarta.validation.constraints.NotNull;
*/
public
interface TryLockSimple extends TryLock {
+ /**
+ * 尝试使用锁执行指定回调
+ *