From 2797bf55755816fbd1e7c4f6d982a51b5901f492 Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Fri, 30 Oct 2026 17:49:31 +0800
Subject: [PATCH] feat(gateApi): 添加加仓停止阈值功能以控制加仓执行次数
---
src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java | 191 +++++++++++++++++++++++++++++++++++++----------
1 files changed, 150 insertions(+), 41 deletions(-)
diff --git a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java b/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
index ac5024b..3292f83 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
+++ b/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);
@@ -1765,7 +1771,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());
@@ -1839,7 +1845,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());
@@ -1907,6 +1913,75 @@
}
/**
+ * 根据 {@code stopLossCountMode} 计算当前有效的加仓执行次数（与止损次数的统计口径一致）。
+ * <p>加仓执行次数 = 真正产生额外加仓量（addMultiplier > 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 > 0，即 addQty > 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,37 +1997,37 @@
* <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
* （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
* </ul>
+ * <p>加仓停止阈值 {@code addPositionStopThreshold}：</p>
+ * <ul>
+ * <li>{@code 0} = 不限制；</li>
+ * <li>{@code > 0} 时按「加仓执行次数」（真正产生额外加仓量 addMultiplier > 0 的执行）计数，
+ * 达到该次数后不再追加加仓量 {@code addQty}，下单量回到 {@code baseQuantity}。</li>
+ * </ul>
*
* @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();
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) {
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) {
@@ -1998,15 +2073,18 @@
// 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = calculateEntryQuantity(true, true);
- log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
- getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
+ String size = calculateEntryQuantity(true, true, Integer.parseInt(config.getQuantity()));
+ 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 位置的所有多单
@@ -2061,15 +2139,18 @@
// 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = calculateEntryQuantity(false, true);
- log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
- getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
+ String size = calculateEntryQuantity(false, true, Integer.parseInt(config.getQuantity()));
+ 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 位置的所有空单
@@ -2321,14 +2402,17 @@
int baseQty = Integer.parseInt(config.getBaseQuantity());
int gridCount = baseQty / qty;
GridElement entryElem = GridElement.findById(gridId);
- if (gridCount <= 0 || filledQty < qty) {
+ if (gridCount <= 0 || filledQty <= 0) {
// 早期返回需重置防重入标记
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
}
- // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
- int totalOrders = filledQty / qty;
+ // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈；
+ // 持仓不足一个网格量时也按剩余张数挂一张止损（手动重建场景，避免裸奔）
+ int slSize = Math.min(filledQty, baseQty);
+ int totalOrders = slSize / qty;
+ int remainder = slSize % qty;
int[] orders = new int[gridCount];
if (gridCount == 1) {
@@ -2352,6 +2436,7 @@
for (int i = 0; i < gridCount; i++) {
if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
}
+ if (remainder > 0) { totalOrdersToPlace += 1; }
if (totalOrdersToPlace == 0) {
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
@@ -2362,13 +2447,23 @@
for (int i = 0; i < gridCount; i++) {
if (orders[i] > 0) {
int sgId = gridId - 2 - i;
- placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ placeStopLossOrders(sgId, orders[i], String.valueOf(qty), FuturesPriceTrigger.RuleEnum.NUMBER_2,
ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
if (detail.length() > 0) {
detail.append(" ");
}
detail.append(sgId).append("x").append(orders[i]);
}
+ }
+ // 不足一个网格量的余数：单独挂一张止损
+ if (remainder > 0) {
+ int sgId = gridId - 2 - totalOrders;
+ placeStopLossOrders(sgId, 1, String.valueOf(remainder), FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
+ if (detail.length() > 0) {
+ detail.append(" ");
+ }
+ detail.append(sgId).append("x").append(remainder);
}
log.info("[Gate] 多仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
@@ -2384,14 +2479,17 @@
int baseQty = Integer.parseInt(config.getBaseQuantity());
int gridCount = baseQty / qty;
GridElement entryElem = GridElement.findById(gridId);
- if (gridCount <= 0 || filledQty < qty) {
+ if (gridCount <= 0 || filledQty <= 0) {
// 早期返回需重置防重入标记
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
}
- // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
- int totalOrders = filledQty / qty;
+ // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈；
+ // 持仓不足一个网格量时也按剩余张数挂一张止损（手动重建场景，避免裸奔）
+ int slSize = Math.min(filledQty, baseQty);
+ int totalOrders = slSize / qty;
+ int remainder = slSize % qty;
int[] orders = new int[gridCount];
if (gridCount == 1) {
@@ -2415,6 +2513,7 @@
for (int i = 0; i < gridCount; i++) {
if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
}
+ if (remainder > 0) { totalOrdersToPlace += 1; }
if (totalOrdersToPlace == 0) {
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
@@ -2425,13 +2524,23 @@
for (int i = 0; i < gridCount; i++) {
if (orders[i] > 0) {
int sgId = gridId + 2 + i;
- placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ placeStopLossOrders(sgId, orders[i], String.valueOf(qty), FuturesPriceTrigger.RuleEnum.NUMBER_1,
ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
if (detail.length() > 0) {
detail.append(" ");
}
detail.append(sgId).append("x").append(orders[i]);
}
+ }
+ // 不足一个网格量的余数：单独挂一张止损
+ if (remainder > 0) {
+ int sgId = gridId + 2 + totalOrders;
+ placeStopLossOrders(sgId, 1, String.valueOf(remainder), FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
+ if (detail.length() > 0) {
+ detail.append(" ");
+ }
+ detail.append(sgId).append("x").append(remainder);
}
log.info("[Gate] 空仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
@@ -2469,7 +2578,7 @@
/**
* 在指定网格位置挂 count 个独立止损单，每个 size 张。
*/
- private void placeStopLossOrders(int gridId, int count, int qty,
+ private void placeStopLossOrders(int gridId, int count, String qtyStr,
FuturesPriceTrigger.RuleEnum rule,
String orderType, boolean isLong,
AtomicInteger remainCount,
@@ -2502,8 +2611,8 @@
return;
}
BigDecimal triggerPrice = elem.getGridPrice();
+ String size = isLong ? negate(qtyStr) : qtyStr;
for (int i = 0; i < count; i++) {
- String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
int finalGridId = gridId;
int finalI = i;
executor.placeTakeProfit(
@@ -2944,10 +3053,10 @@
/**
* 分散止盈：把超出基础仓位的部分，从入场网格下一格开始逐格挂止盈单，
- * 一直挂到对手盘止损位的前一格（不含止损位那一格）。
+ * 一直挂到对手盘止损位（包含止损位那一格）。
*
* <p>数量分配：每个网格至少挂 1 张；当 excessQty < 网格数时，张数不够则从起点逐格各挂 1 张、
- * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位的前一格）。
+ * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位那一格）。
*
* <p>方向：多仓成交向价格更高方向（id 递增）铺到空仓第一止损位；
* 空仓成交向价格更低方向（id 递减）铺到多仓第一止损位。
@@ -2970,8 +3079,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);
@@ -3010,7 +3119,7 @@
for (int i = 0; i < n; i++) {
int qty;
if (excessQty >= n) {
- // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位的前一格）
+ // 超额仓位 ≥ 网格数：每格 perGrid，余数堆最后一格（即止损位那一格）
qty = perGrid;
if (i == n - 1) {
qty += remainder;
@@ -3047,7 +3156,7 @@
* 基础止盈：对基础仓位（baseQuantity）也挂止盈单，与超额止盈并行。
*
* <p>规则：从入场网格下一格（entryGridId ± 1）开始，每格 baseTakeProfitPerGrid 张，
- * 最多挂 baseTakeProfitGridCount 格，挂到止损位的前一格截止（与分散止盈同起点/同终点）。
+ * 最多挂 baseTakeProfitGridCount 格，挂到止损位前 2 格截止（即对手盘仓位线）。
*
* <p>边界：累计张数到 min(baseQuantity, 当前持仓) 即停（张数不足则最后一格挂剩余 = "挂几个算几个"）；
* 网格不足时挂到停止位置结束。
@@ -3079,8 +3188,8 @@
}
int dir = isLong ? 1 : -1;
int startId = entryGridId + dir;
- // 分配范围到止损位的前一格截止（与分散止盈一致）
- int endId = endElem.getId() - dir;
+ // 分配范围到止损位前 2 格截止（即对手盘仓位线）
+ int endId = endElem.getId() - 2 * dir;
BigDecimal remaining = BigDecimal.valueOf(maxQty);
int placed = 0;
--
Gitblit v1.9.1