version 1.0.0.0 update

ZongXR · ZongXR · commit 3961c7f9bbca · 2022-02-05T00:11:55.000+08:00
修复时长溢出的BUG;完善乐观锁，现在可以使用自定义的乐观锁，并指定最长等待时间、最长执行时间、是否强制执行等，全方位避免死锁
diff --git a/README.md b/README.md
@@ -79,4 +79,7 @@
 <tr>
 <td>0.9.0.0</td><td>完善读写锁注解，现在可以使用自定义的读写锁</td><td>2022年2月4日</td>
 </tr>
+<tr>
+<td>1.0.0.0</td><td>修复时长溢出的BUG;完善乐观锁，现在可以使用自定义的乐观锁，并指定最长等待时间、最长执行时间、是否强制执行等，全方位避免死锁</td><td>2022年2月5日</td>
+</tr>
 </table>
diff --git a/src/main/java/org/springframework/lock/annotation/OptimisticLock.java b/src/main/java/org/springframework/lock/annotation/OptimisticLock.java
@@ -11,9 +11,39 @@
 @Documented
 public @interface OptimisticLock {
 
+    /**
+     * 乐观锁变量的名称
+     * @return 默认使用自动生成的锁
+     */
+    String value() default "";
+
     /**
      * 乐观锁忙等待周期毫秒数
      * @return 乐观锁忙等待时间
      */
-    long value() default 500L;
+    long pollingTime() default 500L;
+
+    /**
+     * 最长等待时间
+     * @return 默认Long.MAX_VALUE
+     */
+    long waitTime() default Long.MAX_VALUE;
+
+    /**
+     * 最长执行时间，超过此时间自动解锁
+     * @return 默认Long.MAX_VALUE
+     */
+    long executeTime() default Long.MAX_VALUE;
+
+    /**
+     * 是否强制执行，如果等待时间耗尽还没有拿到锁的话，是否还要执行
+     * @return 默认放弃
+     */
+    boolean isContinueIfElapsed() default false;
+
+    /**
+     * 如果强制执行，是否中断其他线程以强制获得锁. 该属性仅在{@code isContinueIfElapsed}为{@code true}时才生效
+     * @return 默认否
+     */
+    boolean withLockIfContinue() default false;
 }
diff --git a/src/main/java/org/springframework/lock/annotation/ReadLock.java b/src/main/java/org/springframework/lock/annotation/ReadLock.java
@@ -45,7 +45,7 @@
     boolean isContinueIfElapsed() default false;
 
     /**
-     * 如果强制执行，是否中断其他线程以强制获得锁
+     * 如果强制执行，是否中断其他线程以强制获得锁.该属性仅在{@code isContinueIfElapsed}为{@code true}时才生效
      * @return 默认否
      */
     boolean withLockIfContinue() default false;
diff --git a/src/main/java/org/springframework/lock/annotation/WriteLock.java b/src/main/java/org/springframework/lock/annotation/WriteLock.java
@@ -45,7 +45,7 @@
     boolean isContinueIfElapsed() default false;
 
     /**
-     * 如果强制执行，是否中断其他线程以强制获得锁
+     * 如果强制执行，是否中断其他线程以强制获得锁. 该属性仅在{@code isContinueIfElapsed}为{@code true}时才生效
      * @return 默认否
      */
     boolean withLockIfContinue() default false;
diff --git a/src/main/java/org/springframework/lock/aspect/OptimisticLockAspect.java b/src/main/java/org/springframework/lock/aspect/OptimisticLockAspect.java
@@ -7,12 +7,16 @@
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.reflect.MethodSignature;
 import org.springframework.lock.annotation.OptimisticLock;
+import org.springframework.lock.timer.InterruptTimer;
+import org.springframework.util.StringUtils;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
 
 import static java.lang.Thread.sleep;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
 /**
  * 乐观锁的切面
@@ -33,48 +37,143 @@ public class OptimisticLockAspect {
      */
     @Around("@annotation(org.springframework.lock.annotation.OptimisticLock)")
     public Object aroundOptimisticLock(ProceedingJoinPoint jp) throws Throwable {
-        Object obj = jp.getTarget();
-        Class<?> clz = obj.getClass();
-        // 获取等待时长，默认500毫秒
-        long waitTime = 500L;
+        // 获取注解属性值
+        long pollingTime = 500L;
+        long waitTime = Long.MAX_VALUE;
+        long executeTime = Long.MAX_VALUE;
+        boolean isContinueIfElapsed = false;
+        boolean withLockIfContinue = false;
+        String lockName = null;
+
         MethodSignature signature = (MethodSignature) jp.getSignature();
         Method method = signature.getMethod();
-        if (method != null) {
-            OptimisticLock annotation = method.getAnnotation(OptimisticLock.class);
-            if (annotation != null) {
-                waitTime = annotation.value();
-            }
+        OptimisticLock annotation = method.getAnnotation(OptimisticLock.class);
+        if (annotation != null) {
+            pollingTime = annotation.pollingTime();
+            waitTime = annotation.waitTime();
+            executeTime = annotation.executeTime();
+            isContinueIfElapsed = annotation.isContinueIfElapsed();
+            withLockIfContinue = annotation.withLockIfContinue();
+            lockName = annotation.value();
         }
+
         // 获取锁对象
-        AtomicBoolean lock = null;
-        for (Field field : clz.getDeclaredFields()) {
-            if ("$opLock".equals(field.getName())){
-                field.setAccessible(true);
-                Object unknownLock = field.get(obj);
-                lock = (AtomicBoolean) unknownLock;
-            }
+        AtomicLong lock = null;
+        Object obj = jp.getTarget();
+        Class<?> clz = obj.getClass();
+        Field field = null;
+
+        if (StringUtils.hasText(lockName)){
+            field = clz.getDeclaredField(lockName);
+            field.setAccessible(true);
+            lock = (AtomicLong) field.get(obj);
+        }else{
+            field = clz.getDeclaredField("$opLock");
+            field.setAccessible(true);
+            lock = (AtomicLong) field.get(obj);
+        }
+
+        if (lock == null){
+            LOGGER.warn(clz.getSimpleName() + "获取锁错误，请检查锁名称是否正确");
+            return jp.proceed();
         }
+
+        // 尝试加锁，不行就解掉别人的锁
         Object result = null;
-        if (lock != null){
-            while (true){
-                if (lock.compareAndSet(true, false))
-                    // 拿到了锁
-                    break;
-                else
-                    // 如果没拿到锁就忙等待
-                    sleep(waitTime);
+        boolean locked = this.tryLock(lock, waitTime, pollingTime);
+        if (locked){
+            result = this.processMethod(jp, lock, executeTime);
+        }else {
+            if (isContinueIfElapsed){
+                if (withLockIfContinue){
+                    Thread lockedThread = findThread(lock.get());
+                    if (lockedThread == null)
+                        result = this.processMethod(jp, lock, executeTime);
+                    else {
+                        lockedThread.interrupt();
+                        if (this.tryLock(lock, waitTime, pollingTime)){
+                            LOGGER.warn("等待时间耗尽，终止线程" + lockedThread + "以强制获得乐观锁@" + lock.hashCode());
+                            result = this.processMethod(jp, lock, executeTime);
+                        }else {
+                            lockedThread.stop();
+                            if (this.tryLock(lock, waitTime, pollingTime)){
+                                LOGGER.warn("等待时间耗尽，终止线程" + lockedThread + "以强制获得乐观锁@" + lock.hashCode());
+                                result = this.processMethod(jp, lock, executeTime);
+                            }
+                        }
+                    }
+                }else {
+                    LOGGER.warn("等待时间耗尽，将不带锁执行" + method.getName());
+                    result = jp.proceed();
+                }
+            }else {
+                LOGGER.warn("等待时间耗尽，放弃执行" + method.getName());
             }
-            try {
-                LOGGER.info(clz.getSimpleName() + "获得乐观锁");
-                result = jp.proceed();
-                LOGGER.info(clz.getSimpleName() + "释放乐观锁");
-            }finally {
-                lock.set(true);
-            }
-        }else{
-            LOGGER.warn(clz.getSimpleName() + "生成乐观锁失败,未能加锁");
+        }
+        return result;
+    }
+
+    /**
+     * 处理方法
+     * @param jp 切入点
+     * @param lock 乐观锁，调用方法前必须加锁
+     * @param executeTime 最长执行时间，超出此时间结束线程
+     * @return 原方法返回值
+     * @throws Throwable 异常
+     */
+    private Object processMethod(ProceedingJoinPoint jp, AtomicLong lock, long executeTime) throws Throwable {
+        Object result = null;
+        LOGGER.info(Thread.currentThread().getName() + "获得乐观锁@" + lock.hashCode());
+        if (System.currentTimeMillis() + executeTime > 0)
+            new InterruptTimer(Thread.currentThread(), executeTime);
+        try{
             result = jp.proceed();
+        } finally {
+            LOGGER.info(Thread.currentThread().getName() + "释放乐观锁@" + lock.hashCode());
+            lock.set(0);
         }
         return result;
     }
+
+    /**
+     * 通过线程id获取线程
+     * @param threadId 线程id
+     * @return 线程
+     */
+    private static Thread findThread(long threadId) {
+        ThreadGroup group = Thread.currentThread().getThreadGroup();
+        while(group != null) {
+            Thread[] threads = new Thread[(int)(group.activeCount() * 1.2)];
+            int count = group.enumerate(threads, true);
+            for(int i = 0; i < count; i++) {
+                if(threadId == threads[i].getId()) {
+                    return threads[i];
+                }
+            }
+            group = group.getParent();
+        }
+        return null;
+    }
+
+    /**
+     * 忙等待，直到超时或获取锁
+     * @param lock 锁
+     * @param waitTime 最长等待时长
+     * @param pollingTime 轮询周期
+     * @return 是否获得锁
+     */
+    private boolean tryLock(AtomicLong lock, long waitTime, long pollingTime) throws InterruptedException {
+        long startWaitTime = System.currentTimeMillis();
+        while (true){
+            if (lock.compareAndSet(0, Thread.currentThread().getId())) {
+                // 拿到了锁
+                return true;
+            }else if (System.currentTimeMillis() - startWaitTime > waitTime)
+                // 超时了
+                return false;
+            else
+                // 如果没拿到锁就忙等待
+                sleep(pollingTime);
+        }
+    }
 }
diff --git a/src/main/java/org/springframework/lock/aspect/ReadLockAspect.java b/src/main/java/org/springframework/lock/aspect/ReadLockAspect.java
@@ -126,7 +126,8 @@ public Object aroundReadLock(ProceedingJoinPoint jp) throws Throwable {
     private Object processMethod(ProceedingJoinPoint jp, Lock readLock, long executeTime) throws Throwable {
         Object result = null;
         LOGGER.info(Thread.currentThread().getName() + "获得读锁" + readLock);
-        new InterruptTimer(Thread.currentThread(), executeTime);
+        if (System.currentTimeMillis() + executeTime > 0)
+            new InterruptTimer(Thread.currentThread(), executeTime);
         try {
             result = jp.proceed();
         } finally {
diff --git a/src/main/java/org/springframework/lock/aspect/WriteLockAspect.java b/src/main/java/org/springframework/lock/aspect/WriteLockAspect.java
@@ -127,7 +127,8 @@ public Object aroundWriteLock(ProceedingJoinPoint jp) throws Throwable {
     private Object processMethod(ProceedingJoinPoint jp, Lock writeLock, long executeTime) throws Throwable {
         Object result = null;
         LOGGER.info(Thread.currentThread().getName() + "获得写锁" + writeLock);
-        new InterruptTimer(Thread.currentThread(), executeTime);
+        if (System.currentTimeMillis() + executeTime > 0)
+            new InterruptTimer(Thread.currentThread(), executeTime);
         try {
             result = jp.proceed();
         } finally {
diff --git a/src/main/java/org/springframework/lock/processor/OptimisticLockProcessor.java b/src/main/java/org/springframework/lock/processor/OptimisticLockProcessor.java
diff --git a/src/test/java/example/name/controller/BaseController.java b/src/test/java/example/name/controller/BaseController.java
diff --git a/src/test/java/example/name/service/BaseService.java b/src/test/java/example/name/service/BaseService.java
