Merge branches 'master' and 'ver1.1' of http://git.tbd.yanzuoguang.com/yzg/yzg-util

yzg-util-base/src/main/java/com/yanzuoguang/util/helper/YzgTimeout.java

@@ -2,8 +2,12 @@ package com.yanzuoguang.util.helper;
 
 import com.yanzuoguang.util.log.Log;
 import com.yanzuoguang.util.thread.ThreadHelper;
-import com.yanzuoguang.util.vo.Ref;
 
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
 /**
@@ -15,7 +19,9 @@ public class YzgTimeout {
 
     public static final int TIME_OUT_DEFAULT = 15 * 1000;
     public static final int TIME_OUT_TIP = 10 * 1000;
-    public static final int TIME_OUT_UNIT = 10;
+    private static ExecutorService executorService;
+    private static final Queue<TimeInfo> queueInfos = new ArrayBlockingQueue<>(500);
+
 
     /**
      * 超时监控
@@ -36,7 +42,7 @@ public class YzgTimeout {
      * @param runnable 运行函数
      */
     public static void timeOut(Class<?> cls, String message, Runnable runnable, Consumer<Long> consumer) {
-        timeHeart(TIME_OUT_DEFAULT, TIME_OUT_UNIT, TIME_OUT_TIP, runnable, (time) -> {
+        timeHeart(TIME_OUT_DEFAULT, TIME_OUT_TIP, runnable, (time) -> {
             Log.error(cls, "%s超时,已经执行%d豪秒,正在等待执行完成", message, time);
             if (consumer != null) {
                 consumer.accept(time);
@@ -51,7 +57,7 @@ public class YzgTimeout {
      * @param heart    心跳函数
      */
     public static void timeHeart(Runnable runnable, YzgTimeoutHeart heart) {
-        timeHeart(1000, 1000, 10, runnable, heart);
+        timeHeart(TIME_OUT_DEFAULT, TIME_OUT_TIP, runnable, heart);
     }
 
     /**
@@ -59,36 +65,126 @@ public class YzgTimeout {
      *
      * @param tipOutDefault 默认超时时间
      * @param timeOutTip    超时心跳间隔
-     * @param tipUnit       监听间隔时间(监听任务完成间隔时间)
      * @param runnable      运行函数
      * @param heart         心跳函数
      */
-    public static void timeHeart(int tipOutDefault, int timeOutTip, int tipUnit,
+    public static void timeHeart(int tipOutDefault, int timeOutTip,
                                  Runnable runnable, YzgTimeoutHeart heart) {
-        final Ref<Boolean> isRun = new Ref<>(false);
-        ThreadHelper.runThread(() -> {
-            try {
-                long timeMax = tipOutDefault;
-                long start = System.currentTimeMillis();
-                do {
-                    long end = System.currentTimeMillis();
-                    long time = end - start;
-                    if (time > timeMax) {
-                        timeMax += timeOutTip;
-                        heart.heart(time);
-                    }
-                    ThreadHelper.sleep(tipUnit);
-                } while (!isRun.value);
-            } catch (Exception ex) {
-                ex.printStackTrace();
-            }
-        });
+        TimeInfo timeInfo = getTimeInfo(tipOutDefault, timeOutTip, heart);
         try {
             runnable.run();
         } finally {
-            synchronized (isRun) {
-                isRun.value = true;
+            synchronized (timeInfo) {
+                timeInfo.setRun(true);
+            }
+        }
+    }
+
+    private static TimeInfo getTimeInfo(int tipOutDefault, int timeOutTip, YzgTimeoutHeart heart) {
+        init();
+        TimeInfo timeInfo = new TimeInfo(tipOutDefault, timeOutTip, heart);
+        queueInfos.add(timeInfo);
+        return timeInfo;
+    }
+
+    private static void init() {
+        synchronized (YzgTimeout.class) {
+            if (executorService == null) {
+                executorService = new ThreadPoolExecutor(1, 10, 1000,
+                        TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10));
+            }
+        }
+        ThreadHelper.runThread(() -> {
+            while (true) {
+                runItem();
+                ThreadHelper.sleep(1000);
+            }
+        });
+    }
+
+    private static void runItem() {
+        int size = queueInfos.size();
+        for (int i = 0; i < size; i++) {
+            TimeInfo poll = queueInfos.poll();
+            long end = System.currentTimeMillis();
+            long time = end - poll.getStart();
+            if (time > poll.getTimeMax()) {
+                try {
+                    poll.setTimeMax(poll.getTimeMax() + poll.getTimeOutTip());
+                    executorService.submit(() -> poll.getHeart().heart(time));
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                }
+            }
+            if (!poll.isRun()) {
+                queueInfos.add(poll);
             }
         }
     }
 }
+
+class TimeInfo {
+
+    private int timeOutDefault;
+    private int timeOutTip;
+    private YzgTimeoutHeart heart;
+    private boolean run;
+    private long start;
+    private int timeMax;
+
+    public TimeInfo(int timeOutDefault, int timeOutTip, YzgTimeoutHeart heart) {
+        this.timeOutDefault = timeOutDefault;
+        this.timeOutTip = timeOutTip;
+        this.heart = heart;
+        this.timeMax = timeOutDefault;
+        this.start = System.currentTimeMillis();
+    }
+
+    public int getTimeOutDefault() {
+        return timeOutDefault;
+    }
+
+    public void setTimeOutDefault(int timeOutDefault) {
+        this.timeOutDefault = timeOutDefault;
+    }
+
+    public int getTimeOutTip() {
+        return timeOutTip;
+    }
+
+    public void setTimeOutTip(int timeOutTip) {
+        this.timeOutTip = timeOutTip;
+    }
+
+    public YzgTimeoutHeart getHeart() {
+        return heart;
+    }
+
+    public void setHeart(YzgTimeoutHeart heart) {
+        this.heart = heart;
+    }
+
+    public boolean isRun() {
+        return run;
+    }
+
+    public void setRun(boolean run) {
+        this.run = run;
+    }
+
+    public long getStart() {
+        return start;
+    }
+
+    public void setStart(long start) {
+        this.start = start;
+    }
+
+    public int getTimeMax() {
+        return timeMax;
+    }
+
+    public void setTimeMax(int timeMax) {
+        this.timeMax = timeMax;
+    }
+}

yzg-util-base/src/test/java/helper/TestTimeout.java

+package helper;
+
+import com.yanzuoguang.util.helper.YzgTimeout;
+import com.yanzuoguang.util.thread.ThreadHelper;
+import org.junit.Test;
+
+public class TestTimeout {
+
+    @Test
+    public void test() {
+        YzgTimeout.timeOut(TestTimeout.class, "消息", new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("开始运行");
+                ThreadHelper.sleep(1 * 60 * 1000);
+                System.out.println("结束运行");
+            }
+        }, (time) -> {
+            // System.err.println("已经等待" + time);
+        });
+    }
+}