``` fix(gateApi): 修复止损追单时持仓计算时序竞态问题

Administrator

2 days ago af0ccd5b31da3a0e44885a9cf1051701411350f6

 src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java

@@ -609,14 +609,16 @@

                log.info("[Gate] 重置策略，开始第{}轮...", currentRound);
                state = StrategyState.STOPPED;
                try {
                    futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
                } catch (ApiException e) {
                    e.printStackTrace();
                }
                closeExistingPositions();
                // 提交到 executor 末尾：单线程FIFO保证前面所有平仓/取消任务完成后才重置
                // 关键修复：取消+平仓+延时+重启必须整体放进 executor 队列末尾，让上一轮排队的
                // 挂单任务先执行完（挂到交易所），随后的 cancel 才能取消到它们。若 cancel 仍留在
                // WS 线程同步执行，会早于上一轮挂单任务，取消不到"尚未挂出"的单（竞态）。
                executor.submitTask(() -> {
                    try {
                        futuresApi.cancelPriceTriggeredOrderList(SETTLE, config.getContract());
                    } catch (ApiException e) {
                        e.printStackTrace();
                    }
                    closeExistingPositions();
                    try { Thread.sleep(3000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                    // 注意：startGrid() 会将 currentRound 归零，这里需要保留
                    int savedRound = currentRound;
@@ -836,8 +838,9 @@
                lastShortStopLossGridId = Integer.MAX_VALUE;
                // [Gate-需求2] 加仓后先撤空仓所有止盈+止损，再查交易所持仓后重挂
                cancelAllShortTakeProfitsAndStopLosses();
                // REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
                int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
                // REST/WS 持仓可能因交易所延迟返回旧值（仓位归零后重开甚至为 0），
                // 与本次成交张数 filledQty 取最大值兜底，避免 posSize=0 导致止盈止损全部跳过
                int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()), filledQty);
                extendShortStopLoss(posSize, shortGridElement.getId());
                // [Gate] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位
                if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
@@ -886,8 +889,9 @@
                lastLongStopLossGridId = Integer.MAX_VALUE;
                // [Gate-需求2] 加仓后先撤多仓所有止盈+止损，再查交易所持仓后重挂
                cancelAllLongTakeProfitsAndStopLosses();
                // REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
                int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
                // REST/WS 持仓可能因交易所延迟返回旧值（仓位归零后重开甚至为 0），
                // 与本次成交张数 filledQty 取最大值兜底，避免 posSize=0 导致止盈止损全部跳过
                int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()), filledQty);
                extendLongStopLoss(posSize, longGridElement.getId());
                // [Gate] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位
                if (GateConfig.EXCESS_TP_CONCENTRATED.equals(config.getPlaceExcessTakeProfit())) {
@@ -1761,7 +1765,7 @@
//                        String quantity = String.valueOf(config.getBaseQuantity());


                        String quantity = calculateEntryQuantity(true, false);
                        String quantity = calculateEntryQuantity(true, false, 0);
                        // 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
                        boolean hasLongOrderBelow = false;
                        GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
@@ -1835,7 +1839,7 @@
//                        String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
//                        String quantity = String.valueOf(config.getBaseQuantity());

                        String quantity = calculateEntryQuantity(false, false);
                        String quantity = calculateEntryQuantity(false, false, 0);
                        // 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
                        boolean hasShortOrderAbove = false;
                        GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId());
@@ -1921,9 +1925,10 @@
     *
     * @param isLong                 {@code true}=多仓方向，{@code false}=空仓方向
     * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
     * @param stopLossSize           本次止损单张数（仅止损追单场景传入，用于修正 REST 时序竞态；其余场景传 0）
     * @return 实际下单张数（字符串）
     */
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition) {
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition, int stopLossSize) {
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int interval = config.getAddPositionInterval();
        int addQtyPerUnit = config.getAddPositionQuantity();
@@ -1944,11 +1949,14 @@
            int upperLimit = maxPerSide;
            if (respectCurrentPosition) {
                // 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
                // 止损单刚成交、WS 持仓推送尚未到达，必须用 REST 实时查询绕过 WS 缓存时序竞态，
                // 否则会取到滞后的旧持仓（如止损前仍为 10），把追单量错误扣减。
                // 止损单刚成交、REST 查询可能仍返回止损前持仓（时序竞态），
                // 减去本次止损单张数得到止损后的真实持仓，避免追单量被错误扣减。
                int currentPos = isLong
                        ? queryPositionSize(Position.ModeEnum.DUAL_LONG)
                        : queryPositionSize(Position.ModeEnum.DUAL_SHORT);
                if (stopLossSize > 0) {
                    currentPos = Math.max(0, currentPos - stopLossSize);
                }
                upperLimit = maxPerSide - currentPos;
            }
            if (upperLimit <= 0) {
@@ -1994,7 +2002,7 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(true, true);
        String size = calculateEntryQuantity(true, true, Integer.parseInt(config.getQuantity()));
        log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
@@ -2057,7 +2065,7 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(false, true);
        String size = calculateEntryQuantity(false, true, Integer.parseInt(config.getQuantity()));
        log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
@@ -2940,10 +2948,10 @@

    /**
     * 分散止盈：把超出基础仓位的部分，从入场网格下一格开始逐格挂止盈单，
     * 一直挂到对手盘止损位的前一格（不含止损位那一格）。
     * 一直挂到对手盘止损位（包含止损位那一格）。
     *
     * <p>数量分配：每个网格至少挂 1 张；当 excessQty &lt; 网格数时，张数不够则从起点逐格各挂 1 张、
     * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位的前一格）。
     * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位那一格）。
     *
     * <p>方向：多仓成交向价格更高方向（id 递增）铺到空仓第一止损位；
     * 空仓成交向价格更低方向（id 递减）铺到多仓第一止损位。
@@ -2966,8 +2974,8 @@
        }
        int dir = isLong ? 1 : -1;
        int startId = entryGridId + dir;
        // 分配范围到止损位的前一格截止（不含止损位那一格）
        int endId = endElem.getId() - dir;
        // 分配范围到止损位那一格截止（包含止损位）
        int endId = endElem.getId();

        // 终点必须在起点前进方向上，否则退化为集中止盈（全部挂对手盘止损位）
        boolean valid = isLong ? (endId >= startId) : (endId <= startId);
@@ -3006,7 +3014,7 @@
        for (int i = 0; i < n; i++) {
            int qty;
            if (excessQty >= n) {
                // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位的前一格）
                // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位那一格）
                qty = perGrid;
                if (i == n - 1) {
                    qty += remainder;
@@ -3043,7 +3051,7 @@
     * 基础止盈：对基础仓位（baseQuantity）也挂止盈单，与超额止盈并行。
     *
     * <p>规则：从入场网格下一格（entryGridId ± 1）开始，每格 baseTakeProfitPerGrid 张，
     * 最多挂 baseTakeProfitGridCount 格，挂到止损位的前一格截止（与分散止盈同起点/同终点）。
     * 最多挂 baseTakeProfitGridCount 格，挂到止损位前 2 格截止（即对手盘仓位线）。
     *
     * <p>边界：累计张数到 min(baseQuantity, 当前持仓) 即停（张数不足则最后一格挂剩余 = "挂几个算几个"）；
     * 网格不足时挂到停止位置结束。
@@ -3053,9 +3061,9 @@
     * @param entryGridId 入场网格 ID
     */
    private void placeBaseTakeProfit(int posSize, boolean isLong, int entryGridId) {
        int perGrid = config.getBaseTakeProfitPerGrid();
        BigDecimal perGrid = config.getBaseTakeProfitPerGrid();
        int gridCount = config.getBaseTakeProfitGridCount();
        if (perGrid <= 0 || gridCount <= 0) {
        if (perGrid == null || perGrid.compareTo(BigDecimal.ZERO) <= 0 || gridCount <= 0) {
            return;
        }
        int baseQty = Integer.parseInt(config.getBaseQuantity());
@@ -3075,13 +3083,13 @@
        }
        int dir = isLong ? 1 : -1;
        int startId = entryGridId + dir;
        // 分配范围到止损位的前一格截止（与分散止盈一致）
        int endId = endElem.getId() - dir;
        // 分配范围到止损位前 2 格截止（即对手盘仓位线）
        int endId = endElem.getId() - 2 * dir;

        int remaining = maxQty;
        BigDecimal remaining = BigDecimal.valueOf(maxQty);
        int placed = 0;
        int id = startId;
        while (placed < gridCount && remaining > 0) {
        while (placed < gridCount && remaining.compareTo(BigDecimal.ZERO) > 0) {
            if (isLong ? id > endId : id < endId) {
                break;
            }
@@ -3089,11 +3097,11 @@
            if (elem == null) {
                break;
            }
            int qty = Math.min(perGrid, remaining);
            BigDecimal qty = perGrid.min(remaining);
            final GridElement fe = elem;
            final int gid = id;
            final BigDecimal triggerPrice = elem.getGridPrice();
            final String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
            final String size = isLong ? negate(qty.toPlainString()) : qty.toPlainString();
            final String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT;
            final FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1
                    : FuturesPriceTrigger.RuleEnum.NUMBER_2;
@@ -3108,7 +3116,7 @@
                                isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
                    }
            );
            remaining -= qty;
            remaining = remaining.subtract(qty);
            placed++;
            id += dir;
        }