feat(api): 优化玩家数据API并发处理和线程安全

ShinoyukiMiyako · ShinoyukiMiyako · commit 716bbc8be1fb · 2025-10-02T05:44:21.000+08:00
- 为PlayerDataApiController添加插件依赖和并发查询限制
- 使用CompletableFuture和Bukkit调度器确保主线程调用Bukkit API
- 添加查询超时机制(3秒)和并发信号量控制(最多5个并发)
- 移除对离线玩家数据的查询支持，仅处理在线玩家
- 增加友好的错误提示和日志记录

refactor(database): 提升数据库并发性能和连接稳定性

- 增加数据库线程池大小从3到8以处理更多并发操作
- 为SQLite连接启用WAL模式、缓存优化等性能配置
- 设置busy_timeout为30秒，避免锁等待超时
- 为每个数据库连接单独设置PRAGMA busy_timeout
- 添加WAL自动检查点配置提升写入性能

perf(sync): 调整同步任务处理器启动延迟和超时设置

- 任务处理器启动延迟从0秒调整为10秒，避免启动时数据库过载
- 获取待处理任务的查询超时时间从5秒增加到15秒
- 为SQL查询显式设置10秒查询超时
- 增强超时异常处理，避免任务处理中断

fix(whitelist): 修复PlayerDataApiController插件依赖注入

- 在WhitelistSystem中为PlayerDataApiController正确传递Plugin实例
diff --git a/src/main/java/com/xaoxiao/convenientaccess/api/PlayerDataApiController.java b/src/main/java/com/xaoxiao/convenientaccess/api/PlayerDataApiController.java
@@ -5,6 +5,8 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -26,18 +28,26 @@
 /**
  * 玩家数据API控制器
  * 处理玩家详细数据查询的API请求
+ * 注意: 所有Bukkit API调用都必须在主线程中执行
  */
 public class PlayerDataApiController {
     private static final Logger logger = LoggerFactory.getLogger(PlayerDataApiController.class);
     
     private final Gson gson;
+    private final org.bukkit.plugin.Plugin plugin;
     
-    public PlayerDataApiController() {
+    // 并发查询限制
+    private final java.util.concurrent.Semaphore querySemaphore = new java.util.concurrent.Semaphore(5);
+    
+    public PlayerDataApiController(org.bukkit.plugin.Plugin plugin) {
         this.gson = new Gson();
+        this.plugin = plugin;
     }
     
     /**
      * 处理GET /api/v1/player?name=玩家名 - 获取玩家详细数据
+     * 注意: 必须在主线程中调用Bukkit API以避免线程安全问题
+     * 优化: 添加并发限制和更短的超时时间
      */
     public void handleGetPlayerData(HttpServletRequest request, HttpServletResponse response) throws IOException {
         // 从查询参数中获取玩家名
@@ -49,29 +59,49 @@ public void handleGetPlayerData(HttpServletRequest request, HttpServletResponse
                 return;
             }
             
-            // 首先尝试通过玩家名获取在线玩家
-            Player onlinePlayer = Bukkit.getPlayerExact(playerName);
+            // 尝试获取查询许可(最多5个并发查询)
+            if (!querySemaphore.tryAcquire(100, TimeUnit.MILLISECONDS)) {
+                logger.warn("查询请求过多,拒绝查询玩家: {}", playerName);
+                sendJsonResponse(response, 429, ApiResponse.error("查询请求过多,请稍后再试"));
+                return;
+            }
             
-            if (onlinePlayer != null) {
-                // 玩家在线，获取完整数据
-                PlayerData playerData = collectOnlinePlayerData(onlinePlayer);
-                sendJsonResponse(response, 200, ApiResponse.success(playerData, "成功获取玩家数据（在线）"));
-                logger.info("成功获取在线玩家数据: {}", playerName);
-            } else {
-                // 玩家离线，尝试获取离线玩家数据
-                @SuppressWarnings("deprecation")
-                OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(playerName);
+            try {
+                // 使用CompletableFuture在主线程中执行Bukkit API调用
+                CompletableFuture<PlayerData> future = new CompletableFuture<>();
+                
+                Bukkit.getScheduler().runTask(plugin, () -> {
+                    try {
+                        // 只查询在线玩家
+                        Player onlinePlayer = Bukkit.getPlayerExact(playerName);
+                        
+                        if (onlinePlayer != null && onlinePlayer.isOnline()) {
+                            // 玩家在线，获取完整数据
+                            PlayerData playerData = collectOnlinePlayerData(onlinePlayer);
+                            future.complete(playerData);
+                        } else {
+                            future.completeExceptionally(new IllegalArgumentException("玩家不在线或不存在"));
+                        }
+                    } catch (Exception e) {
+                        future.completeExceptionally(e);
+                    }
+                });
+                
+                // 缩短超时时间到3秒 - 如果服务器TPS不健康,快速失败
+                PlayerData playerData = future.get(3, TimeUnit.SECONDS);
+                sendJsonResponse(response, 200, ApiResponse.success(playerData, "成功获取玩家数据"));
+                logger.debug("成功获取在线玩家数据: {}", playerName);
                 
-                if (offlinePlayer.hasPlayedBefore()) {
-                    PlayerData playerData = collectOfflinePlayerData(offlinePlayer);
-                    sendJsonResponse(response, 200, ApiResponse.success(playerData, "成功获取玩家数据（离线）"));
-                    logger.info("成功获取离线玩家数据: {}", playerName);
-                } else {
-                    sendJsonResponse(response, 404, ApiResponse.notFound("玩家不存在或从未登录过服务器"));
-                    logger.warn("玩家不存在: {}", playerName);
-                }
+            } finally {
+                querySemaphore.release();
             }
             
+        } catch (IllegalArgumentException e) {
+            sendJsonResponse(response, 404, ApiResponse.notFound(e.getMessage()));
+            logger.debug("玩家不在线: {}", playerName);
+        } catch (java.util.concurrent.TimeoutException e) {
+            logger.warn("获取玩家数据超时(3秒): {} - 服务器TPS可能不健康", playerName);
+            sendJsonResponse(response, 504, ApiResponse.error("服务器繁忙,请稍后重试(TPS过低)"));
         } catch (Exception e) {
             logger.error("获取玩家数据时发生错误: {}", playerName, e);
             sendJsonResponse(response, 500, ApiResponse.error("获取玩家数据失败: " + e.getMessage()));
diff --git a/src/main/java/com/xaoxiao/convenientaccess/database/DatabaseManager.java b/src/main/java/com/xaoxiao/convenientaccess/database/DatabaseManager.java
@@ -1,20 +1,24 @@
 package com.xaoxiao.convenientaccess.database;
 
-import com.xaoxiao.convenientaccess.ConvenientAccessPlugin;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.sql.*;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.xaoxiao.convenientaccess.ConvenientAccessPlugin;
+
 /**
  * SQLite数据库管理器
  * 负责数据库连接池管理、初始化、迁移和事务管理
@@ -33,7 +37,8 @@ public class DatabaseManager {
     public DatabaseManager(ConvenientAccessPlugin plugin) {
         this.plugin = plugin;
         this.databasePath = plugin.getDataFolder().getAbsolutePath() + File.separator + "whitelist.db";
-        this.executorService = Executors.newFixedThreadPool(3, r -> {
+        // 增加线程池大小以处理更多并发数据库操作
+        this.executorService = Executors.newFixedThreadPool(8, r -> {
             Thread thread = new Thread(r, "DatabaseManager-Thread");
             thread.setDaemon(true);
             return thread;
@@ -54,13 +59,15 @@ public CompletableFuture<Boolean> initialize() {
                 
                 // 创建数据库连接
                 try (Connection connection = getConnection()) {
-                    // 启用外键约束
+                    // 启用外键约束和优化并发性能
                     try (Statement stmt = connection.createStatement()) {
                         stmt.execute("PRAGMA foreign_keys = ON");
                         stmt.execute("PRAGMA journal_mode = WAL");
                         stmt.execute("PRAGMA synchronous = NORMAL");
                         stmt.execute("PRAGMA cache_size = 10000");
                         stmt.execute("PRAGMA temp_store = MEMORY");
+                        stmt.execute("PRAGMA busy_timeout = 30000"); // 设置30秒的锁等待超时
+                        stmt.execute("PRAGMA wal_autocheckpoint = 1000"); // WAL自动检查点
                     }
                     
                     // 检查数据库版本
@@ -90,7 +97,14 @@ public CompletableFuture<Boolean> initialize() {
      * 获取数据库连接
      */
     public Connection getConnection() throws SQLException {
-        return DriverManager.getConnection("jdbc:sqlite:" + databasePath);
+        Connection conn = DriverManager.getConnection("jdbc:sqlite:" + databasePath);
+        // 为每个连接设置 busy_timeout，处理并发锁等待
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("PRAGMA busy_timeout = 30000"); // 30秒超时
+        } catch (SQLException e) {
+            logger.warn("设置 busy_timeout 失败: {}", e.getMessage());
+        }
+        return conn;
     }
     
     /**
diff --git a/src/main/java/com/xaoxiao/convenientaccess/sync/SyncTaskManager.java b/src/main/java/com/xaoxiao/convenientaccess/sync/SyncTaskManager.java
@@ -384,11 +384,14 @@ public CompletableFuture<Long> scheduleUuidUpdate(String name, String uuid) {
      * 启动任务处理器
      */
     private void startTaskProcessor() {
+        // 延迟10秒后开始处理任务,避免启动时数据库繁忙
         // 每5秒检查一次待处理任务
-        scheduler.scheduleWithFixedDelay(this::processPendingTasks, 0, 5, TimeUnit.SECONDS);
+        scheduler.scheduleWithFixedDelay(this::processPendingTasks, 10, 5, TimeUnit.SECONDS);
         
-        // 每30秒清理已完成的任务
+        // 延迟30秒后开始清理,每30秒清理一次已完成的任务
         scheduler.scheduleWithFixedDelay(this::cleanupCompletedTasks, 30, 30, TimeUnit.SECONDS);
+        
+        logger.info("任务处理器已启动,将在10秒后开始处理待处理任务");
     }
     
     /**
@@ -425,6 +428,7 @@ private List<SyncTask> getPendingTasks(int limit) {
                 List<SyncTask> tasks = new ArrayList<>();
                 try (PreparedStatement stmt = connection.prepareStatement(sql)) {
                     stmt.setInt(1, limit);
+                    stmt.setQueryTimeout(10); // 设置SQL查询超时为10秒
                     
                     try (ResultSet rs = stmt.executeQuery()) {
                         while (rs.next()) {
@@ -433,7 +437,10 @@ private List<SyncTask> getPendingTasks(int limit) {
                     }
                 }
                 return tasks;
-            }).get(5, TimeUnit.SECONDS);
+            }).get(15, TimeUnit.SECONDS); // 增加超时时间到15秒
+        } catch (java.util.concurrent.TimeoutException e) {
+            logger.warn("获取待处理任务超时,可能数据库繁忙,将在下次调度时重试");
+            return new ArrayList<>();
         } catch (Exception e) {
             logger.error("获取待处理任务失败", e);
             return new ArrayList<>();
diff --git a/src/main/java/com/xaoxiao/convenientaccess/whitelist/WhitelistSystem.java b/src/main/java/com/xaoxiao/convenientaccess/whitelist/WhitelistSystem.java
@@ -94,7 +94,7 @@ public CompletableFuture<Boolean> initialize() {
                 // 初始化API组件
                 whitelistApiController = new WhitelistApiController(whitelistManager, syncTaskManager);
                 userApiController = new UserApiController(registrationTokenManager, whitelistManager);
-                PlayerDataApiController playerDataApiController = new PlayerDataApiController();
+                PlayerDataApiController playerDataApiController = new PlayerDataApiController(plugin);
                 
                 // 设置管理员密码到UserApiController
                 userApiController.setAdminPassword(adminPassword);
