Merge branch 'master' of https://github.com/flowerfine/milky-all

flowerfine · Nov 29, 2024 · 0e41608 · 0e41608
2 parents b9a64a0 + 1afefca
commit 0e41608
Show file tree

Hide file tree

Showing 51 changed files with 817 additions and 207 deletions.
diff --git a/milky-common/pom.xml b/milky-common/pom.xml
@@ -27,6 +27,11 @@
             <artifactId>disruptor</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
@@ -44,12 +49,6 @@
             <artifactId>jackson-dataformat-properties</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>com.google.guava</groupId>
-            <artifactId>guava</artifactId>
-            <version>30.1.1-jre</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>cn.sliew</groupId>
             <artifactId>milky-test</artifactId>

diff --git a/milky-common/src/main/java/cn/sliew/milky/common/concurrent/AbstractLoopRunnable.java b/milky-common/src/main/java/cn/sliew/milky/common/concurrent/AbstractLoopRunnable.java
@@ -0,0 +1,16 @@
+package cn.sliew.milky.common.concurrent;
+
+public abstract class AbstractLoopRunnable implements LoopRunnable {
+
+    protected volatile boolean terminal = false;
+
+    @Override
+    public void terminate() {
+        terminal = true;
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return terminal;
+    }
+}
diff --git a/...iew/milky/thread/DaemonThreadFactory.java → ...ommon/concurrent/DaemonThreadFactory.java b/...iew/milky/thread/DaemonThreadFactory.java → ...ommon/concurrent/DaemonThreadFactory.java
@@ -1,15 +1,11 @@
-package cn.sliew.milky.thread;
+package cn.sliew.milky.common.concurrent;
 
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static cn.sliew.milky.common.check.Ensures.checkNotNull;
-import static cn.sliew.milky.common.check.Ensures.notBlank;
 
-/**
- * todo thread context。当创建线程的时候初始化线程的ThreadContext？？
- */
-class DaemonThreadFactory implements ThreadFactory {
+public class DaemonThreadFactory implements ThreadFactory {
 
     private final String threadNamePrefix;
     private final int threadPriority;
@@ -23,15 +19,15 @@ public DaemonThreadFactory() {
         this(null);
     }
 
-    DaemonThreadFactory(String threadNamePrefix) {
+    public DaemonThreadFactory(String threadNamePrefix) {
         this(threadNamePrefix, true);
     }
 
     public DaemonThreadFactory(String threadNamePrefix, int threadPriority) {
         this(threadNamePrefix, threadPriority, true);
     }
 
-    DaemonThreadFactory(String threadNamePrefix, boolean daemon) {
+    public DaemonThreadFactory(String threadNamePrefix, boolean daemon) {
         this(threadNamePrefix, Thread.NORM_PRIORITY, daemon);
     }
 

diff --git a/milky-common/src/main/java/cn/sliew/milky/common/concurrent/LoopRunnable.java b/milky-common/src/main/java/cn/sliew/milky/common/concurrent/LoopRunnable.java
@@ -0,0 +1,17 @@
+package cn.sliew.milky.common.concurrent;
+
+public interface LoopRunnable extends Runnable {
+
+    void execute();
+
+    void terminate();
+
+    boolean isTerminated();
+
+    @Override
+    default void run() {
+        while (isTerminated() == false) {
+            execute();
+        }
+    }
+}
diff --git a/milky-common/src/main/java/cn/sliew/milky/common/concurrent/RunnableWrapper.java b/milky-common/src/main/java/cn/sliew/milky/common/concurrent/RunnableWrapper.java
@@ -1,5 +1,7 @@
 package cn.sliew.milky.common.concurrent;
 
+import java.util.concurrent.RejectedExecutionException;
+
 public interface RunnableWrapper extends Runnable {
 
     @Override
@@ -8,7 +10,9 @@ default void run() {
             onBefore();
             doRun();
             onAfter();
-        } catch (Exception t) {
+        } catch (RejectedExecutionException t) {
+            onRejection(t);
+        }  catch (Exception t) {
             onFailure(t);
         } finally {
             onFinal();
@@ -27,6 +31,14 @@ default void run() {
      */
     void onFailure(Exception e);
 
+    /**
+     * This should be executed if the thread-pool executing this action rejected the execution.
+     * The default implementation forwards to {@link #onFailure(Exception)}
+     */
+    default void onRejection(Exception e) {
+        onFailure(e);
+    }
+
     /**
      * This method is called before all execution for init.
      */
@@ -48,4 +60,11 @@ default void onAfter() throws Exception {
     default void onFinal() {
         // nothing by default
     }
+
+    /**
+     * Should the runnable force its execution in case it gets rejected?
+     */
+    default boolean isForceExecution() {
+        return false;
+    }
 }
diff --git a/milky-common/src/main/java/cn/sliew/milky/common/concurrent/ThreadPoolUtil.java b/milky-common/src/main/java/cn/sliew/milky/common/concurrent/ThreadPoolUtil.java
@@ -0,0 +1,28 @@
+package cn.sliew.milky.common.concurrent;
+
+import java.util.concurrent.*;
+
+public enum ThreadPoolUtil {
+    ;
+
+    private static ConcurrentMap<String, ExecutorService> executors = new ConcurrentHashMap<>();
+
+    private static ExecutorService init(String poolName, int poolSize) {
+        return new ThreadPoolExecutor(poolSize, poolSize,
+                0L, TimeUnit.MILLISECONDS,
+                new LinkedBlockingQueue<Runnable>(),
+                new DaemonThreadFactory("Pool-" + poolName, true),
+                new ThreadPoolExecutor.CallerRunsPolicy());
+    }
+
+    public static ExecutorService getOrInitExecutors(String poolName, int poolSize) {
+        return executors.computeIfAbsent(poolName, key -> init(poolName, poolSize));
+    }
+
+    public static void releaseExecutors(String poolName) {
+        ExecutorService executorService = executors.remove(poolName);
+        if (executorService != null) {
+            executorService.shutdown();
+        }
+    }
+}
diff --git a/milky-common/src/main/java/cn/sliew/milky/common/unit/MoneyUnit.java b/milky-common/src/main/java/cn/sliew/milky/common/unit/MoneyUnit.java
@@ -0,0 +1,132 @@
+package cn.sliew.milky.common.unit;
+
+import java.math.BigDecimal;
+
+public enum MoneyUnit {
+
+    HAO {
+        @Override
+        public BigDecimal toHao(BigDecimal size) {
+            return size;
+        }
+
+        @Override
+        public BigDecimal toFen(BigDecimal size) {
+            return size.divide(C1.divide(C0));
+        }
+
+        @Override
+        public BigDecimal toJiao(BigDecimal size) {
+            return size.divide(C2.divide(C0));
+        }
+
+        @Override
+        public BigDecimal toYuan(BigDecimal size) {
+            return size.divide(C3.divide(C0));
+        }
+
+        @Override
+        public String getSuffix() {
+            return "毫";
+        }
+    },
+
+    FEN {
+
+        @Override
+        public BigDecimal toHao(BigDecimal size) {
+            return size.multiply(C1.divide(C0));
+        }
+
+        @Override
+        public BigDecimal toFen(BigDecimal size) {
+            return size;
+        }
+
+        @Override
+        public BigDecimal toJiao(BigDecimal size) {
+            return size.divide(C2.divide(C1));
+        }
+
+        @Override
+        public BigDecimal toYuan(BigDecimal size) {
+            return size.divide(C3.divide(C1));
+        }
+
+        @Override
+        public String getSuffix() {
+            return "分";
+        }
+    },
+
+    JIAO {
+        @Override
+        public BigDecimal toHao(BigDecimal size) {
+            return size.multiply(C2.divide(C0));
+        }
+
+        @Override
+        public BigDecimal toFen(BigDecimal size) {
+            return size.multiply(C2.divide(C1));
+        }
+
+        @Override
+        public BigDecimal toJiao(BigDecimal size) {
+            return size;
+        }
+
+        @Override
+        public BigDecimal toYuan(BigDecimal size) {
+            return size.divide(C3.divide(C2));
+        }
+
+        @Override
+        public String getSuffix() {
+            return "角";
+        }
+    },
+
+    YUAN {
+        @Override
+        public BigDecimal toHao(BigDecimal size) {
+            return size.multiply(C3.divide(C0));
+        }
+
+        @Override
+        public BigDecimal toFen(BigDecimal size) {
+            return size.multiply(C3.divide(C1));
+        }
+
+        @Override
+        public BigDecimal toJiao(BigDecimal size) {
+            return size.multiply(C3.divide(C2));
+        }
+
+        @Override
+        public BigDecimal toYuan(BigDecimal size) {
+            return size;
+        }
+
+        @Override
+        public String getSuffix() {
+            return "元";
+        }
+    };
+
+    static final BigDecimal _TEN = BigDecimal.TEN;
+    static final BigDecimal _HUNDRED = BigDecimal.valueOf(100L);
+    static final BigDecimal C0 = BigDecimal.ONE;
+    static final BigDecimal C1 = C0.multiply(_HUNDRED);
+    static final BigDecimal C2 = C1.multiply(_TEN);
+    static final BigDecimal C3 = C2.multiply(_TEN);
+
+    public abstract BigDecimal toHao(BigDecimal size);
+
+    public abstract BigDecimal toFen(BigDecimal size);
+
+    public abstract BigDecimal toJiao(BigDecimal size);
+
+    public abstract BigDecimal toYuan(BigDecimal size);
+
+    public abstract String getSuffix();
+}