Merge branch 'dev' of github.com:SlimefunGuguProject/Slimefun4 into dev

# 请输入一个提交信息以解释此合并的必要性，尤其是将一个更新后的上游分支
# 合并到主题分支。
#
# 以 '#' 开始的行将被忽略，而空的提交说明将终止提交。

Author: neokoni

.github/workflows/spotless.yml

@@ -1,4 +1,5 @@
-name: spotless.yml
+name: Spotless
+
 on:
 #  push:
 #    branches: [ master, dev ]
@@ -10,13 +11,16 @@ on:
     paths:
       - 'src/**'
       - 'pom.xml'
+#  workflow_dispatch:
 
 env:
   TZ: 'Asia/Shanghai'
 
 jobs:
   spotless:
     runs-on: ubuntu-latest
+    outputs:
+        spotless-status: ${{ steps.spotless-check.outputs.status }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -32,34 +36,40 @@ jobs:
 
       - name: Spotless check
         id: spotless-check
-        run: mvn -B spotless:check --errors
-        continue-on-error: ${{ github.event_name == 'push' }}
+        run: |
+          set +e
+          mvn -B spotless:check --errors
+          STATUS=$?
+          echo "status=$STATUS" >> $GITHUB_OUTPUT
+          set -e
+          exit $STATUS
+        continue-on-error: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' }}
 
       - name: Spotless apply (if needed)
         id: spotless-apply
-        if: ${{ github.github.event_name == 'push' && failure() && steps.spotless-check.outcome == 'failure' }}
+        if: ${{ (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && steps.spotless-check.outputs.status != '0' }}
         run: mvn -B spotless:apply --errors
 
       - name: Push changes
         uses: EndBug/add-and-commit@v9.1.4
-        if: ${{ github.github.event_name == 'push'}}
+        if: ${{ (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && steps.spotless-check.outputs.status != '0' && success()}}
         with:
-          github_token: ${{ secrets.ACCESS_TOKEN }}
+          github_token: ${{ secrets.BOT_ACCESS_TOKEN }}
           add: '.'
           push: true
-          message: 'chore(ci): spotless'
+          message: 'chore(style): spotless apply'
           author_name: 'noraincity-bot'
           author_email: ${{ secrets.BOT_EMAIL }}
           committer_name: 'noraincity-bot'
           committer_email: ${{ secrets.BOT_EMAIL }}
   call-dev-ci:
     needs: [ spotless ]
-    if: ${{ github.event_name == 'PushEvent' && github.ref_name == 'dev' }}
+    if: ${{ (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref_name == 'dev' }}
     uses: ./.github/workflows/dev-ci.yml
     secrets: inherit
   call-beta-ci:
     needs: [ spotless ]
-    if: ${{ github.event_name == 'push' && github.ref_name == 'master' }}
+    if: ${{ (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref_name == 'master' }}
     uses: ./.github/workflows/build-ci.yml
     secrets: inherit
   call-pr-checker:

src/main/java/city/norain/slimefun4/timings/SQLProfiler.java

@@ -16,17 +16,19 @@
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
 import java.util.logging.Level;
 import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
 import lombok.Getter;
 import org.bukkit.command.CommandSender;
 
 public class SQLProfiler {
-    private final ThreadFactory threadFactory = r -> new Thread(r, "Slimefun SQL Profiler");
-
-    private final ExecutorService executor = Executors.newFixedThreadPool(2, threadFactory);
+    private final ExecutorService reportExecutor = Executors.newFixedThreadPool(1, r -> {
+        Thread t = new Thread(r, "Slimefun SQL Reporter");
+        t.setUncaughtExceptionHandler((et, e) -> Slimefun.logger()
+                .log(Level.SEVERE, "A error occurred in sql report generator thread " + et.getName(), e));
+        return t;
+    });
 
     @Getter
     private volatile boolean isProfiling = false;
@@ -39,6 +41,10 @@ public class SQLProfiler {
 
     private long startTime = -1L;
 
+    public void initSlowSqlCheck(@Nonnull Slimefun plugin) {
+        Slimefun.getFoliaLib().getScheduler().runTimerAsync(new SlowSqlCheckTask(() -> samplingEntries), 20L, 20L);
+    }
+
     public void start() {
         if (isProfiling) return;
 
@@ -82,7 +88,13 @@ public void stop() {
         samplingEntries.clear();
         isProfiling = false;
 
-        executor.execute(this::generateReport);
+        reportExecutor.execute(this::generateReport);
+    }
+
+    public void shutdown() {
+        stop();
+
+        reportExecutor.shutdownNow();
     }
 
     public void generateReport() {

src/main/java/city/norain/slimefun4/timings/SlowSqlCheckTask.java

@@ -0,0 +1,30 @@
+package city.norain.slimefun4.timings;
+
+import city.norain.slimefun4.timings.entry.TimingEntry;
+import io.github.thebusybiscuit.slimefun4.implementation.Slimefun;
+import java.util.Map;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+public class SlowSqlCheckTask implements Runnable {
+    private final Supplier<Map<TimingEntry, Long>> statusChecker;
+
+    public SlowSqlCheckTask(Supplier<Map<TimingEntry, Long>> statusChecker) {
+        this.statusChecker = statusChecker;
+    }
+
+    @Override
+    public void run() {
+        for (Map.Entry<TimingEntry, Long> mapEntry : statusChecker.get().entrySet()) {
+            var entry = mapEntry.getKey();
+            var startTime = mapEntry.getValue();
+
+            long elapsedTime = System.currentTimeMillis() - startTime;
+
+            if (elapsedTime > 5000) {
+                Slimefun.logger().log(Level.WARNING, "检测到慢 SQL: {0}", entry.normalize());
+                break;
+            }
+        }
+    }
+}

src/main/java/city/norain/slimefun4/timings/entry/SQLEntry.java

@@ -16,4 +16,9 @@ public String getIdentifier() {
     public String normalize() {
         return sql;
     }
+
+    @Override
+    public int hashCode() {
+        return sql.hashCode();
+    }
 }

src/main/java/city/norain/slimefun4/utils/ControllerPoolExecutor.java

@@ -0,0 +1,74 @@
+package city.norain.slimefun4.utils;
+
+import io.github.thebusybiscuit.slimefun4.implementation.Slimefun;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import javax.annotation.Nonnull;
+import lombok.Getter;
+
+public class SlimefunPoolExecutor extends ThreadPoolExecutor {
+    @Getter
+    private final String name;
+
+    @Getter
+    private final List<Thread> runningThreads = new CopyOnWriteArrayList<>();
+
+    public SlimefunPoolExecutor(
+            String name,
+            int corePoolSize,
+            int maximumPoolSize,
+            long keepAliveTime,
+            @Nonnull TimeUnit unit,
+            @Nonnull BlockingQueue<Runnable> workQueue,
+            @Nonnull ThreadFactory threadFactory) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
+
+        this.name = name;
+
+        Slimefun.getProfiler().registerPool(this);
+    }
+
+    @Override
+    protected void beforeExecute(Thread t, Runnable r) {
+        super.beforeExecute(t, r);
+
+        runningThreads.add(t);
+    }
+
+    @Override
+    protected void afterExecute(Runnable r, Throwable t) {
+        try {
+            super.afterExecute(r, t);
+
+            if (t != null) {
+                Slimefun.logger()
+                        .log(
+                                Level.WARNING,
+                                "An error occurred in " + name + "("
+                                        + Thread.currentThread().getName() + ")",
+                                t);
+            }
+
+            if (r instanceof FutureTask<?> future) {
+                try {
+                    future.get();
+                } catch (Exception e) {
+                    Slimefun.logger()
+                            .log(
+                                    Level.WARNING,
+                                    "An error occurred in " + name + "("
+                                            + Thread.currentThread().getName() + ")",
+                                    t);
+                }
+            }
+        } finally {
+            runningThreads.remove(Thread.currentThread());
+        }
+    }
+}

src/main/java/city/norain/slimefun4/utils/SlimefunPoolExecutor.java

@@ -2,6 +2,8 @@
 
 import com.xzavier0722.mc.plugin.slimefun4.storage.controller.attributes.UniversalDataTrait;
 import io.github.thebusybiscuit.slimefun4.api.items.SlimefunItem;
+import java.lang.management.ThreadInfo;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 import org.bukkit.inventory.ItemStack;
@@ -48,4 +50,77 @@ public static String getTraitsStr(Set<UniversalDataTrait> traits) {
 
         return String.join(",", traits.stream().map(Enum::name).toList());
     }
+
+    /**
+     * 格式化详细线程信息
+     */
+    public static String formatDetailedThreadInfo(ThreadInfo threadInfo) {
+        StringBuilder sb = new StringBuilder();
+
+        // 线程名和基本信息
+        sb.append(threadInfo.getThreadName());
+        sb.append(" #").append(threadInfo.getThreadId());
+        sb.append(" ").append(threadInfo.getThreadState());
+
+        // 锁信息
+        if (threadInfo.getLockName() != null) {
+            sb.append(" on ").append(threadInfo.getLockName());
+            if (threadInfo.getLockOwnerName() != null) {
+                sb.append(" owned by \"").append(threadInfo.getLockOwnerName()).append("\"");
+                sb.append(" #").append(threadInfo.getLockOwnerId());
+            }
+        }
+
+        sb.append("\n");
+
+        // 线程状态详情
+        sb.append("   Thread.State: ").append(threadInfo.getThreadState());
+        if (threadInfo.getBlockedTime() > 0) {
+            sb.append(" (blocked for ").append(threadInfo.getBlockedTime()).append("ms)");
+        }
+        if (threadInfo.getWaitedTime() > 0) {
+            sb.append(" (waited for ").append(threadInfo.getWaitedTime()).append("ms)");
+        }
+        sb.append("\n");
+
+        // 堆栈跟踪
+        StackTraceElement[] stackTrace = threadInfo.getStackTrace();
+        for (int i = 0; i < stackTrace.length; i++) {
+            StackTraceElement element = stackTrace[i];
+            sb.append("\tat ").append(element.toString()).append("\n");
+
+            // 第一个堆栈元素的锁信息
+            if (i == 0 && threadInfo.getLockName() != null) {
+                sb.append("\t- ").append(getThreadStateDescription(threadInfo)).append("\n");
+            }
+        }
+
+        // 持有的锁
+        if (threadInfo.getLockedMonitors().length > 0) {
+            sb.append("   Locked monitors:\n");
+            Arrays.stream(threadInfo.getLockedMonitors())
+                    .forEach(monitor ->
+                            sb.append("\t- locked ").append(monitor.toString()).append("\n"));
+        }
+
+        // 持有的同步器
+        if (threadInfo.getLockedSynchronizers().length > 0) {
+            sb.append("   Locked synchronizers:\n");
+            Arrays.stream(threadInfo.getLockedSynchronizers())
+                    .forEach(sync -> sb.append("\t- ").append(sync.toString()).append("\n"));
+        }
+
+        return sb.toString();
+    }
+
+    private static String getThreadStateDescription(ThreadInfo threadInfo) {
+        switch (threadInfo.getThreadState()) {
+            case BLOCKED:
+                return "blocked on " + threadInfo.getLockName();
+            case WAITING, TIMED_WAITING:
+                return "waiting on " + threadInfo.getLockName();
+            default:
+                return threadInfo.getThreadState().toString().toLowerCase();
+        }
+    }
 }