version 0.8.1.0 update

ZongXR · ZongXR · commit 458f1d979985 · 2022-02-04T19:19:20.000+08:00
完善写锁，提供最长等待时间，最长执行时间，是否强制执行等属性，全方位避免死锁
diff --git a/README.md b/README.md
@@ -73,4 +73,7 @@
 <tr>
 <td>0.8.0.0</td><td>完善读锁，提供最长等待时间，最长执行时间，是否强制执行等属性，全方位避免死锁</td><td>2022年2月4日</td>
 </tr>
+<tr>
+<td>0.8.1.0</td><td>完善写锁，提供最长等待时间，最长执行时间，是否强制执行等属性，全方位避免死锁</td><td>2022年2月4日</td>
+</tr>
 </table>
diff --git a/src/main/java/org/springframework/lock/annotation/WriteLock.java b/src/main/java/org/springframework/lock/annotation/WriteLock.java
@@ -19,4 +19,28 @@
      * @return 默认null，如果有自定义值则覆盖默认值
      */
     BooleanEnum fair() default NULL;
+
+    /**
+     * 等待时长，没获得锁的时候最多等待多长时间
+     * @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;
+
+    /**
+     * 如果强制执行，是否中断其他线程以强制获得锁
+     * @return 默认否
+     */
+    boolean withLockIfContinue() default false;
 }
diff --git a/src/main/java/org/springframework/lock/annotation/package-info.java b/src/main/java/org/springframework/lock/annotation/package-info.java
@@ -3,6 +3,6 @@
  * 每个注解上都有对应的注释，写得很清楚，自己看就可以了，不加以赘述.
  * 需要注意的是，如果需要使锁注解生效，需要在springboot启动类上添加{@code @EnableSpringLocks}注解
  * @author 宗祥瑞
- * @version 0.8.0.0
+ * @version 0.8.1.0
  */
 package org.springframework.lock.annotation;
diff --git a/src/main/java/org/springframework/lock/aspect/ReadLockAspect.java b/src/main/java/org/springframework/lock/aspect/ReadLockAspect.java
@@ -15,7 +15,6 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 import static java.util.concurrent.TimeUnit.*;
-import static java.util.concurrent.locks.ReentrantReadWriteLock.*;
 
 /**
  * 用于处理读锁的切面
@@ -39,26 +38,21 @@ public Object aroundReadLock(ProceedingJoinPoint jp) throws Throwable {
         Object obj = jp.getTarget();
         Class<?> clz = obj.getClass();
         Lock readLock = null;
-        Lock writeLock = null;
         ReentrantReadWriteLock lock = null;
         for (Field field : clz.getDeclaredFields()) {
             if ("$readLock".equals(field.getName())){
                 field.setAccessible(true);
                 readLock = (Lock) field.get(obj);
             }
-            if ("$writeLock".equals(field.getName())){
-                field.setAccessible(true);
-                writeLock = (Lock) field.get(obj);
-            }
             if ("$lock".equals(field.getName())){
                 field.setAccessible(true);
                 lock = (ReentrantReadWriteLock) field.get(obj);
             }
-            if (lock != null && readLock != null && writeLock != null)
+            if (lock != null && readLock != null)
                 // 都找到了
                 break;
         }
-        if (readLock == null || lock == null || writeLock == null){
+        if (readLock == null || lock == null){
             // 连锁都没拿到，说明编译期间出了问题
             LOGGER.warn(clz.getSimpleName() + "编译时生成读写锁锁失败,未能加锁");
             return jp.proceed();
@@ -95,10 +89,16 @@ public Object aroundReadLock(ProceedingJoinPoint jp) throws Throwable {
                     Method getOwner = ReentrantReadWriteLock.class.getDeclaredMethod("getOwner");
                     getOwner.setAccessible(true);
                     Thread lockedThread = (Thread) getOwner.invoke(lock);
-                    lockedThread.stop();
-                    LOGGER.warn("等待时间耗尽，终止线程" + lockedThread + "以强制获得锁");
+                    lockedThread.interrupt();
                     if (readLock.tryLock(waitTime, MILLISECONDS)){
+                        LOGGER.warn("等待时间耗尽，终止线程" + lockedThread + "以强制获得锁");
                         result = this.processMethod(jp, readLock, executeTime);
+                    }else{
+                        lockedThread.stop();
+                        if (readLock.tryLock(waitTime, MILLISECONDS)){
+                            LOGGER.warn("等待时间耗尽，终止线程" + lockedThread + "以强制获得锁");
+                            result = this.processMethod(jp, readLock, executeTime);
+                        }
                     }
                 }else {
                     LOGGER.warn("等待时间耗尽，将不带锁执行" + method.getName());
diff --git a/src/main/java/org/springframework/lock/aspect/WriteLockAspect.java b/src/main/java/org/springframework/lock/aspect/WriteLockAspect.java
@@ -5,9 +5,16 @@
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.lock.annotation.WriteLock;
+import org.springframework.lock.timer.InterruptTimer;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
 /**
  * 用于处理写锁的切面
@@ -31,28 +38,98 @@ public Object aroundWriteLock(ProceedingJoinPoint jp) throws Throwable {
         Object obj = jp.getTarget();
         Class<?> clz = obj.getClass();
         Lock writeLock = null;
+        ReentrantReadWriteLock lock = null;
         for (Field field : clz.getDeclaredFields()) {
             if ("$writeLock".equals(field.getName())){
                 field.setAccessible(true);
-                Object unknownLock = field.get(obj);
-                writeLock = (Lock) unknownLock;
+                writeLock = (Lock) field.get(obj);
+            }
+            if ("$lock".equals(field.getName())){
+                field.setAccessible(true);
+                lock = (ReentrantReadWriteLock) field.get(obj);
             }
+            if (lock != null && writeLock != null)
+                // 都找到了
+                break;
         }
+        if (lock == null || writeLock == null){
+            // 连锁都没拿到，说明编译期间出了问题
+            LOGGER.warn(clz.getSimpleName() + "编译时生成读写锁锁失败,未能加锁");
+            return jp.proceed();
+        }
+
+        long waitTime = Long.MAX_VALUE;
+        long executeTime = Long.MAX_VALUE;
+        boolean isContinueIfElapsed = false;
+        boolean withLockIfContinue = false;
+
+        MethodSignature signature = (MethodSignature) jp.getSignature();
+        Method method = signature.getMethod();
+        if (method == null) {
+            // 没拿到方法，那注解给了谁呢？
+            LOGGER.warn("没拿到方法" + signature);
+            return jp.proceed();
+        }
+        WriteLock annotation = method.getAnnotation(WriteLock.class);
+        if (annotation != null) {
+            waitTime = annotation.waitTime();
+            executeTime = annotation.executeTime();
+            isContinueIfElapsed = annotation.isContinueIfElapsed();
+            withLockIfContinue = annotation.withLockIfContinue();
+        }
+
         Object result = null;
-        if (writeLock != null) {
-            writeLock.lock();
-            LOGGER.info(clz.getSimpleName() + "获得写锁");
-            try {
-                result = jp.proceed();
-            } finally {
-                writeLock.unlock();
-                LOGGER.info(clz.getSimpleName() + "释放写锁");
-            }
+        boolean locked = writeLock.tryLock(waitTime, MILLISECONDS);
+        if (locked) {
+            result = this.processMethod(jp, writeLock, executeTime);
         }else {
-            LOGGER.warn(clz.getSimpleName() + "生成读锁失败,未能加锁");
-            result = jp.proceed();
+            if (isContinueIfElapsed){
+                if (withLockIfContinue){
+                    // 解别人锁的逻辑，这是终极大招
+                    Method getOwner = ReentrantReadWriteLock.class.getDeclaredMethod("getOwner");
+                    getOwner.setAccessible(true);
+                    Thread lockedThread = (Thread) getOwner.invoke(lock);
+                    lockedThread.interrupt();
+                    if (writeLock.tryLock(waitTime, MILLISECONDS)){
+                        LOGGER.warn("等待时间耗尽，中断线程" + lockedThread + "以强制获得锁");
+                        result = this.processMethod(jp, writeLock, executeTime);
+                    }else {
+                        lockedThread.stop();
+                        if (writeLock.tryLock(waitTime, MILLISECONDS)) {
+                            LOGGER.warn("等待时间耗尽，终止线程" + lockedThread + "以强制获得锁");
+                            result = this.processMethod(jp, writeLock, executeTime);
+                        }
+                    }
+                }else {
+                    LOGGER.warn("等待时间耗尽，将不带锁执行" + method.getName());
+                    result = jp.proceed();
+                }
+            }else {
+                LOGGER.warn("等待时间耗尽，放弃执行" + method.getName());
+            }
         }
         return result;
     }
 
+
+    /**
+     * 处理方法的过程
+     * @param jp 切入点
+     * @param writeLock 写锁，在调用方法前必须加锁
+     * @param executeTime 最大执行时长
+     * @return 原方法返回值
+     * @throws Throwable 异常
+     */
+    private Object processMethod(ProceedingJoinPoint jp, Lock writeLock, long executeTime) throws Throwable {
+        Object result = null;
+        LOGGER.info(Thread.currentThread().getName() + "获得写锁");
+        new InterruptTimer(Thread.currentThread(), executeTime);
+        try {
+            result = jp.proceed();
+        } finally {
+            writeLock.unlock();
+            LOGGER.info(Thread.currentThread().getName() + "释放写锁");
+        }
+        return result;
+    }
 }
diff --git a/src/main/java/org/springframework/lock/aspect/package-info.java b/src/main/java/org/springframework/lock/aspect/package-info.java
@@ -3,6 +3,6 @@
  * 每个切面都有注释，没什么好说的，不加以赘述.
  * 切面这部分需要托管到spring容器中去执行.
  * @author 宗祥瑞
- * @version 0.8.0.0
+ * @version 0.8.1.0
  */
 package org.springframework.lock.aspect;
diff --git a/src/main/java/org/springframework/lock/enumeration/package-info.java b/src/main/java/org/springframework/lock/enumeration/package-info.java
@@ -1,7 +1,7 @@
 /**
  * 这是关于枚举类型的包.
  * 写得很清楚，直接看代码就好了.
- * @version 0.8.0.0
+ * @version 0.8.1.0
  * @author 宗祥瑞
  */
 package org.springframework.lock.enumeration;
diff --git a/src/main/java/org/springframework/lock/processor/package-info.java b/src/main/java/org/springframework/lock/processor/package-info.java
@@ -4,6 +4,6 @@
  * 它的原理与lombok有些许类似，但代码风格比lombok更好理解，一看就懂
  * 每个处理器都写了注释，写得都很清楚，不加以赘述
  * @author 宗祥瑞
- * @version 0.8.0.0
+ * @version 0.8.1.0
  */
 package org.springframework.lock.processor;
diff --git a/src/main/java/org/springframework/lock/timer/package-info.java b/src/main/java/org/springframework/lock/timer/package-info.java
@@ -3,6 +3,6 @@
  * 意思就是在多长时间后执行什么功能，或者要求每过多长时间执行什么功能.
  * java不能多继承，所以用内部类来实现
  * @author 宗祥瑞
- * @version 0.8.0.0
+ * @version 0.8.1.0
  */
 package org.springframework.lock.timer;
diff --git a/src/test/java/example/name/controller/BaseController.java b/src/test/java/example/name/controller/BaseController.java
@@ -28,6 +28,13 @@ public String testReadLock(){
         return result;
     }
 
+    @RequestMapping(value = "/testWriteLock2", method = RequestMethod.GET)
+    @ResponseBody
+    public String testWriteLock2(){
+        String result = this.baseService.testWriteLock2();
+        return result;
+    }
+
     @RequestMapping(value = "/testWriteLock", method = RequestMethod.GET)
     @ResponseBody
     public String testWriteLock(){
diff --git a/src/test/java/example/name/service/BaseService.java b/src/test/java/example/name/service/BaseService.java
@@ -48,8 +48,8 @@ public String testReadLock() {
         return "testReadLock 执行结束";
     }
 
-    @WriteLock
-    public String testWriteLock(){
+    @WriteLock(fair = TRUE, waitTime = 3000, executeTime = 60000, isContinueIfElapsed = true, withLockIfContinue = true)
+    public String testWriteLock2(){
         String name = Thread.currentThread().getName();
         LOGGER.info(name + "开始执行");
         try {
@@ -58,6 +58,19 @@ public String testWriteLock(){
             e.printStackTrace();
         }
         LOGGER.info(name + "执行结束");
+        return "testWriteLock2 执行结束";
+    }
+
+    @WriteLock(waitTime = 3000, executeTime = 60000, isContinueIfElapsed = true, withLockIfContinue = true)
+    public String testWriteLock(){
+        String name = Thread.currentThread().getName();
+        LOGGER.info(name + "开始执行");
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        LOGGER.info(name + "执行结束");
         return "testWriteLock 执行结束";
     }
 
