``` fix(grid): 修复止损订单张数统计和追单时序竞态问题

Administrator

5 days ago eb365b75c8388d1a30a6659f4692b802a3066097

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

@@ -155,6 +155,10 @@
    private volatile int accumulatedLongLossCount = 0;
    /** 空头累计止损次数（始终递增，加仓订单成交后归零） */
    private volatile int accumulatedShortLossCount = 0;
    /** 多头加仓执行次数（每次真正产生额外加仓量 addMultiplier>0 的多仓止损追单 +1，用于加仓停止阈值判断） */
    private volatile int accumulatedLongAddCount = 0;
    /** 空头加仓执行次数（每次真正产生额外加仓量 addMultiplier>0 的空仓止损追单 +1，用于加仓停止阈值判断） */
    private volatile int accumulatedShortAddCount = 0;
    /** 最近触发止损的多头网格ID */
    private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
    /** 最近触发止损的空头网格ID */
@@ -420,6 +424,8 @@
        shortActive = false;
        accumulatedLongLossCount = 0;
        accumulatedShortLossCount = 0;
        accumulatedLongAddCount = 0;
        accumulatedShortAddCount = 0;
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        dualStopLossModeActive.set(false);
@@ -1098,7 +1104,7 @@
                ORDER_TYPE_CLOSE_SHORT,
                String.valueOf(qty),
                profitId -> {
                    slElem.addShortStopLossOrderId(profitId);
                    slElem.addShortStopLossOrderId(profitId, qty);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓空仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
@@ -1126,7 +1132,7 @@
                ORDER_TYPE_CLOSE_LONG,
                negate(String.valueOf(qty)),
                profitId -> {
                    slElem.addLongStopLossOrderId(profitId);
                    slElem.addLongStopLossOrderId(profitId, qty);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓多仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
@@ -1320,7 +1326,7 @@
                        ORDER_TYPE_CLOSE_LONG,
                        negate(baseQty),
                        profitId -> {
                            longElem.addLongStopLossOrderId(profitId);
                            longElem.addLongStopLossOrderId(profitId, Integer.parseInt(baseQty));
                            GridElement.refreshIndices();
                            log.info("[Gate] 自定义多仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    longPrice, longElem.getId(), triggerPrice, profitId);
@@ -1341,7 +1347,7 @@
                        ORDER_TYPE_CLOSE_SHORT,
                        baseQty,
                        profitId -> {
                            shortElem.addShortStopLossOrderId(profitId);
                            shortElem.addShortStopLossOrderId(profitId, Integer.parseInt(baseQty));
                            GridElement.refreshIndices();
                            log.info("[Gate] 自定义空仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
                                    shortPrice, shortElem.getId(), triggerPrice, profitId);
@@ -1384,7 +1390,7 @@
                    ORDER_TYPE_CLOSE_SHORT,
                    size,
                    profitId -> {
                        elem.addShortStopLossOrderId(profitId);
                        elem.addShortStopLossOrderId(profitId, Integer.parseInt(size));
                        GridElement.refreshIndices();
                        log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
@@ -1411,7 +1417,7 @@
                    ORDER_TYPE_CLOSE_LONG,
                    negate(size),
                    profitId -> {
                        elem.addLongStopLossOrderId(profitId);
                        elem.addLongStopLossOrderId(profitId, Integer.parseInt(size));
                        GridElement.refreshIndices();
                        log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
                    }
@@ -1907,6 +1913,75 @@
    }

    /**
     * 根据 {@code stopLossCountMode} 计算当前有效的加仓执行次数（与止损次数的统计口径一致）。
     * <p>加仓执行次数 = 真正产生额外加仓量（addMultiplier &gt; 0）的止损追单累计次数，
     * 用于加仓停止阈值判断。</p>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @return 有效加仓执行次数
     */
    private int getEffectiveAddCount(boolean isLong) {
        if ("single".equals(config.getStopLossCountMode())) {
            return isLong ? accumulatedLongAddCount : accumulatedShortAddCount;
        }
        // "dual" — 双向总次数
        return accumulatedLongAddCount + accumulatedShortAddCount;
    }

    /**
     * 记录一次加仓执行（用于加仓停止阈值判断）。
     * <p>仅当本次追单的加仓公式<b>真正产生了额外加仓量</b>（addMultiplier &gt; 0，即 addQty &gt; 0）时计数；
     * 只挂基础张数的追单不计入。判断依据 {@link #computeAddQty(boolean)} 与
     * {@link #calculateEntryQuantity(boolean, boolean, int)} 共用同一套计数状态，
     * 同一处理器内止损次数不变，二者结果一致。</p>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     */
    private void recordAddExecution(boolean isLong) {
        if (computeAddQty(isLong) <= 0) {
            // 本次未产生额外加仓量（addMultiplier = 0），不计入执行次数
            return;
        }
        if (isLong) {
            accumulatedLongAddCount++;
        } else {
            accumulatedShortAddCount++;
        }
    }

    /**
     * 计算本次追单的额外加仓量（addQty），供 {@link #calculateEntryQuantity(boolean, boolean, int)}
     * 与 {@link #recordAddExecution(boolean)} 共用，保证「加仓执行」判定与下单计算同源。
     * <pre>
     * effectiveCount = max(0, 累计止损次数 - addPositionStartThreshold)   ← 启动阈值
     * divisor        = addPositionInterval + 1
     * addMultiplier  = floor(effectiveCount / divisor)
     * addQty         = addMultiplier × addPositionQuantity
     * </pre>
     * 加仓停止阈值：加仓执行次数达到 {@code addPositionStopThreshold} 后 addMultiplier 强制归零
     * （addQty = 0），回到基础张数；0 = 不限制。
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @return 额外加仓张数（0 表示本次不加仓）
     */
    private int computeAddQty(boolean isLong) {
        int effectiveCount = getEffectiveStopLossCount(isLong);
        int startThreshold = config.getAddPositionStartThreshold();
        if (startThreshold > 0) {
            effectiveCount = Math.max(0, effectiveCount - startThreshold);
        }
        // 加仓停止阈值：按「加仓执行次数」（真正产生额外加仓量的执行）计数，
        // 已达到停止阈值则加仓量归零，回到基础张数
        int stopThreshold = config.getAddPositionStopThreshold();
        boolean addStopped = stopThreshold > 0 && getEffectiveAddCount(isLong) >= stopThreshold;
        // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
        int interval = config.getAddPositionInterval();
        int divisor = interval + 1;
        int addMultiplier = (!addStopped && interval >= 0) ? effectiveCount / divisor : 0;
        return addMultiplier * config.getAddPositionQuantity();
    }

    /**
     * 根据加仓配置计算入场/追单时的实际下单量。
     * <p>公式：</p>
     * <pre>
@@ -1922,27 +1997,23 @@
     *   <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
     *       （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
     * </ul>
     * <p>加仓停止阈值 {@code addPositionStopThreshold}：</p>
     * <ul>
     *   <li>{@code 0} = 不限制；</li>
     *   <li>{@code > 0} 时按「加仓执行次数」（真正产生额外加仓量 addMultiplier &gt; 0 的执行）计数，
     *       达到该次数后不再追加加仓量 {@code addQty}，下单量回到 {@code baseQuantity}。</li>
     * </ul>
     *
     * @param isLong                 {@code true}=多仓方向，{@code false}=空仓方向
     * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
     * @param stopLossSize           本次止损单张数（仅止损追单场景传入，用于修正 REST 时序竞态；其余场景传 0）
     * @param stopLossSize           本次触发网格的全部止损单张数（仅止损追单场景传入，用于修正 REST 持仓时序竞态；其余场景传 0）
     * @return 实际下单张数（字符串）
     */
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition, int stopLossSize) {
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int interval = config.getAddPositionInterval();
        int addQtyPerUnit = config.getAddPositionQuantity();
        int maxPerSide = config.getMaxPositionPerSide();

        int effectiveCount = getEffectiveStopLossCount(isLong);
        int startThreshold = config.getAddPositionStartThreshold();
        if (startThreshold > 0) {
            effectiveCount = Math.max(0, effectiveCount - startThreshold);
        }
        // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
        int divisor = interval + 1;
        int addMultiplier = interval >= 0 ? effectiveCount / divisor : 0;
        int addQty = addMultiplier * addQtyPerUnit;
        // 额外加仓量由 computeAddQty 统一计算（含启动/停止阈值与间隔公式）
        int addQty = computeAddQty(isLong);
        int totalQty = baseQty + addQty;

        if (maxPerSide > 0) {
@@ -1950,7 +2021,7 @@
            if (respectCurrentPosition) {
                // 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
                // 止损单刚成交、REST 查询可能仍返回止损前持仓（时序竞态），
                // 减去本次止损单张数得到止损后的真实持仓，避免追单量被错误扣减。
                // 减去本网格全部止损张数得到止损后的真实持仓，避免追单量被错误扣减。
                int currentPos = isLong
                        ? queryPositionSize(Position.ModeEnum.DUAL_LONG)
                        : queryPositionSize(Position.ModeEnum.DUAL_SHORT);
@@ -1970,6 +2041,8 @@
    }

    private void handleLongStopLossTriggered(GridElement gridElement, String orderId) {
        // 本网格全部止损单覆盖张数（含刚触发的这一单），用于追单时修正 REST 持仓的时序竞态
        int gridStopLossSize = gridElement.getLongStopLossTotalSize();
        gridElement.removeLongStopLossOrderId(orderId);

        int gridId = gridElement.getId();
@@ -2002,15 +2075,18 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(true, true, Integer.parseInt(config.getQuantity()));
        log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
        String size = calculateEntryQuantity(true, true, gridStopLossSize);
        log.info("[Gate] 多仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), getEffectiveAddCount(true), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 多仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getLongTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
            // 记录加仓执行次数：仅当本次真正产生了额外加仓量（addMultiplier > 0）时计数
            recordAddExecution(true);
        }

        // 取消 gridId+2 位置的所有多单
@@ -2035,6 +2111,8 @@
    }

    private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
        // 本网格全部止损单覆盖张数（含刚触发的这一单），用于追单时修正 REST 持仓的时序竞态
        int gridStopLossSize = gridElement.getShortStopLossTotalSize();
        gridElement.removeShortStopLossOrderId(orderId);

        int gridId = gridElement.getId();
@@ -2065,15 +2143,18 @@

        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(false, true, Integer.parseInt(config.getQuantity()));
        log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
        String size = calculateEntryQuantity(false, true, gridStopLossSize);
        log.info("[Gate] 空仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), getEffectiveAddCount(false), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 空仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getShortTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
            // 记录加仓执行次数：仅当本次真正产生了额外加仓量（addMultiplier > 0）时计数
            recordAddExecution(false);
        }

        // 取消 gridId-2 位置的所有空单
@@ -2317,8 +2398,10 @@
    // ========== 止损追单（新逻辑：3 个固定位置，每个位置挂多个 1 张止损单） ==========

    /**
     * 多仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
     * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
     * 多仓止损追单 — 把当前多头持仓<b>全量</b>拆分为多笔止损单，挂在靠近入场的连续网格上。
     * 网格数 gridCount = baseQuantity / quantity；最近网格挂大部分张数、其余网格各挂 1 笔 quantity 张，
     * 不足一格的余数单独在更远一网格挂一笔。所有异步挂单完成后通过计数器重置防重入标记；
     * 期间若有入场单成交则打 pendingStopLossReExtend 待重挂。
     */
    private void extendLongStopLoss(int filledQty, int gridId) {
        int qty = Integer.parseInt(config.getQuantity());
@@ -2331,9 +2414,9 @@
            return;
        }

        // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈；
        // 持仓不足一个网格量时也按剩余张数挂一张止损（手动重建场景，避免裸奔）
        int slSize = Math.min(filledQty, baseQty);
        // [Gate] 止损覆盖全持仓：加仓部分同样受止损保护，不再只保初始仓位。
        // 取 max 是为了在 REST 时序竞态导致 filledQty 偏小时，至少保住 baseQuantity 的基础仓位
        int slSize = Math.max(filledQty, baseQty);
        int totalOrders = slSize / qty;
        int remainder = slSize % qty;
        int[] orders = new int[gridCount];
@@ -2394,8 +2477,10 @@
    }

    /**
     * 空仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
     * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
     * 空仓止损追单 — 把当前空头持仓<b>全量</b>拆分为多笔止损单，挂在靠近入场的连续网格上。
     * 网格数 gridCount = baseQuantity / quantity；最近网格挂大部分张数、其余网格各挂 1 笔 quantity 张，
     * 不足一格的余数单独在更远一网格挂一笔。所有异步挂单完成后通过计数器重置防重入标记；
     * 期间若有入场单成交则打 pendingStopLossReExtend 待重挂。
     */
    private void extendShortStopLoss(int filledQty, int gridId) {
        int qty = Integer.parseInt(config.getQuantity());
@@ -2408,9 +2493,9 @@
            return;
        }

        // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈；
        // 持仓不足一个网格量时也按剩余张数挂一张止损（手动重建场景，避免裸奔）
        int slSize = Math.min(filledQty, baseQty);
        // [Gate] 止损覆盖全持仓：加仓部分同样受止损保护，不再只保初始仓位。
        // 取 max 是为了在 REST 时序竞态导致 filledQty 偏小时，至少保住 baseQuantity 的基础仓位
        int slSize = Math.max(filledQty, baseQty);
        int totalOrders = slSize / qty;
        int remainder = slSize % qty;
        int[] orders = new int[gridCount];
@@ -2542,9 +2627,9 @@
                    triggerPrice, rule, orderType, size,
                    profitId -> {
                        if (isLong) {
                            elem.addLongStopLossOrderId(profitId);
                            elem.addLongStopLossOrderId(profitId, Integer.parseInt(qtyStr));
                        } else {
                            elem.addShortStopLossOrderId(profitId);
                            elem.addShortStopLossOrderId(profitId, Integer.parseInt(qtyStr));
                        }
                        GridElement.refreshIndices();
                        log.info("[Gate] {}止损追加, gridId:{}, 触发价:{}, 第{}单, stopLossId:{}",