From f3b80c80654cf8a1012d330455f5a1a40b10f5e9 Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Sat, 10 Oct 2026 10:19:24 +0800
Subject: [PATCH] ``` fix(gateApi): 修复止损追单时持仓计算时序竞态问题
---
src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java | 235 ++++++++++++++++++++++++++++++++++++++++++++++------------
1 files changed, 184 insertions(+), 51 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 d8d8c1c..af1bde2 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
+++ b/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())) {
@@ -845,6 +848,8 @@
} else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
placeDispersedTakeProfit(posSize, false, shortGridElement.getId());
}
+ // [Gate] 基础仓位止盈挂单：与超额止盈并行，独立于止盈模式
+ placeBaseTakeProfit(posSize, false, shortGridElement.getId());
log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);
@@ -884,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())) {
@@ -893,6 +899,8 @@
} else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
placeDispersedTakeProfit(posSize, true, longGridElement.getId());
}
+ // [Gate] 基础仓位止盈挂单：与超额止盈并行，独立于止盈模式
+ placeBaseTakeProfit(posSize, true, longGridElement.getId());
log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize);
}
@@ -909,8 +917,8 @@
private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
// 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
- // 清理止盈单状态（已成交）
- longTakeProfitTraderIdParam(tpElem, null, false);
+ // 清理止盈单状态（移除已成交的这笔止盈单）
+ longTakeProfitTraderIdParam(tpElem, orderId, false);
log.info("[Gate] 多仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
GridElement.getLongTakeProfitCount());
@@ -947,8 +955,8 @@
private void handleShortTakeProfitTriggered(GridElement tpElem, String orderId) {
// 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
boolean isLastTp = GridElement.getShortTakeProfitCount() <= 1;
- // 清理止盈单状态（已成交）
- shortTakeProfitTraderIdParam(tpElem, null, false);
+ // 清理止盈单状态（移除已成交的这笔止盈单）
+ shortTakeProfitTraderIdParam(tpElem, orderId, false);
log.info("[Gate] 空仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
GridElement.getShortTakeProfitCount());
@@ -1465,18 +1473,48 @@
GridElement baseElement,String profitId, boolean flag
) {
TraderParam tp = baseElement.getLongTraderParam();
- tp.setTakeProfitOrderId(profitId);
- tp.setTakeProfitPlaced(flag);
- baseElement.setLongTakeProfitOrderId(profitId);
+ if (flag && profitId != null) {
+ // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
+ tp.setTakeProfitOrderId(profitId);
+ tp.setTakeProfitPlaced(true);
+ baseElement.addLongTakeProfitOrderId(profitId);
+ } else {
+ // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
+ tp.setTakeProfitPlaced(false);
+ if (profitId != null) {
+ baseElement.removeLongTakeProfitOrderId(profitId);
+ if (!baseElement.hasLongTakeProfitOrders()) {
+ tp.setTakeProfitOrderId(null);
+ }
+ } else {
+ baseElement.clearLongTakeProfitOrderIds();
+ tp.setTakeProfitOrderId(null);
+ }
+ }
GridElement.refreshIndices();
}
private void shortTakeProfitTraderIdParam(
GridElement baseElement,String profitId, boolean flag
) {
TraderParam tp = baseElement.getShortTraderParam();
- tp.setTakeProfitOrderId(profitId);
- tp.setTakeProfitPlaced(flag);
- baseElement.setShortTakeProfitOrderId(profitId);
+ if (flag && profitId != null) {
+ // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
+ tp.setTakeProfitOrderId(profitId);
+ tp.setTakeProfitPlaced(true);
+ baseElement.addShortTakeProfitOrderId(profitId);
+ } else {
+ // 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
+ tp.setTakeProfitPlaced(false);
+ if (profitId != null) {
+ baseElement.removeShortTakeProfitOrderId(profitId);
+ if (!baseElement.hasShortTakeProfitOrders()) {
+ tp.setTakeProfitOrderId(null);
+ }
+ } else {
+ baseElement.clearShortTakeProfitOrderIds();
+ tp.setTakeProfitOrderId(null);
+ }
+ }
GridElement.refreshIndices();
}
@@ -1727,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());
@@ -1801,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());
@@ -1887,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();
@@ -1910,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) {
@@ -1960,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) {
@@ -2023,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) {
@@ -2202,11 +2244,13 @@
*/
private void cancelAllLongTakeProfitsAndStopLosses() {
for (GridElement e : config.getGridElements()) {
- String tpId = e.getLongTakeProfitOrderId();
- if (tpId != null) {
- e.getLongTraderParam().setTakeProfitPlaced(false);
- e.setLongTakeProfitOrderId(null);
+ for (String tpId : new ArrayList<>(e.getLongTakeProfitOrderIds())) {
executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ e.clearLongTakeProfitOrderIds();
+ if (e.getLongTraderParam() != null) {
+ e.getLongTraderParam().setTakeProfitPlaced(false);
+ e.getLongTraderParam().setTakeProfitOrderId(null);
}
for (String slId : new ArrayList<>(e.getLongStopLossOrderIds())) {
executor.cancelConditionalOrder(slId, oid -> {});
@@ -2222,11 +2266,13 @@
*/
private void cancelAllShortTakeProfitsAndStopLosses() {
for (GridElement e : config.getGridElements()) {
- String tpId = e.getShortTakeProfitOrderId();
- if (tpId != null) {
- e.getShortTraderParam().setTakeProfitPlaced(false);
- e.setShortTakeProfitOrderId(null);
+ for (String tpId : new ArrayList<>(e.getShortTakeProfitOrderIds())) {
executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ e.clearShortTakeProfitOrderIds();
+ if (e.getShortTraderParam() != null) {
+ e.getShortTraderParam().setTakeProfitPlaced(false);
+ e.getShortTraderParam().setTakeProfitOrderId(null);
}
for (String slId : new ArrayList<>(e.getShortStopLossOrderIds())) {
executor.cancelConditionalOrder(slId, oid -> {});
@@ -2241,20 +2287,28 @@
* 首次挂单成交时，取消初始化阶段挂的所有止盈单（多+空），止损单保留不动。
*/
private void cancelAllInitialTakeProfits() {
-
-
GridElement tpElemLong = GridElement.findById(3);
- String longTpId = tpElemLong.getLongTakeProfitOrderId();
- if (longTpId != null) {
- longTakeProfitTraderIdParam(tpElemLong, null, false);
- executor.cancelConditionalOrder(longTpId, oid -> {});
+ if (tpElemLong != null) {
+ for (String tpId : new ArrayList<>(tpElemLong.getLongTakeProfitOrderIds())) {
+ executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ tpElemLong.clearLongTakeProfitOrderIds();
+ if (tpElemLong.getLongTraderParam() != null) {
+ tpElemLong.getLongTraderParam().setTakeProfitPlaced(false);
+ tpElemLong.getLongTraderParam().setTakeProfitOrderId(null);
+ }
}
GridElement tpElemShort = GridElement.findById(-3);
- String shortTpId = tpElemShort.getShortTakeProfitOrderId();
- if (shortTpId != null) {
- shortTakeProfitTraderIdParam(tpElemShort, null, false);
- executor.cancelConditionalOrder(shortTpId, oid -> {});
+ if (tpElemShort != null) {
+ for (String tpId : new ArrayList<>(tpElemShort.getShortTakeProfitOrderIds())) {
+ executor.cancelConditionalOrder(tpId, oid -> {});
+ }
+ tpElemShort.clearShortTakeProfitOrderIds();
+ if (tpElemShort.getShortTraderParam() != null) {
+ tpElemShort.getShortTraderParam().setTakeProfitPlaced(false);
+ tpElemShort.getShortTraderParam().setTakeProfitOrderId(null);
+ }
}
GridElement.refreshIndices();
log.info("[Gate] 首次成交，取消所有初始化止盈单");
@@ -2642,6 +2696,7 @@
} else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
placeDispersedTakeProfit(posSize, true, 0);
}
+ placeBaseTakeProfit(posSize, true, 0);
log.info("[Gate] 生成多仓止盈止损完成, 仓位:{}张", posSize);
});
}
@@ -2664,6 +2719,7 @@
} else if (GateConfig.EXCESS_TP_DISPERSED.equals(config.getPlaceExcessTakeProfit())) {
placeDispersedTakeProfit(posSize, false, 0);
}
+ placeBaseTakeProfit(posSize, false, 0);
log.info("[Gate] 生成空仓止盈止损完成, 仓位:{}张", posSize);
});
}
@@ -2892,10 +2948,10 @@
/**
* 分散止盈：把超出基础仓位的部分，从入场网格下一格开始逐格挂止盈单，
- * 一直挂到对手盘止损位的前一格（不含止损位那一格）。
+ * 一直挂到对手盘止损位（包含止损位那一格）。
*
* <p>数量分配：每个网格至少挂 1 张；当 excessQty < 网格数时，张数不够则从起点逐格各挂 1 张、
- * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位的前一格）。
+ * 挂满 excessQty 张即停止；当 excessQty ≥ 网格数时，每格 excessQty÷n，余数堆最后一格（即止损位那一格）。
*
* <p>方向：多仓成交向价格更高方向（id 递增）铺到空仓第一止损位；
* 空仓成交向价格更低方向（id 递减）铺到多仓第一止损位。
@@ -2918,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);
@@ -2958,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;
@@ -2992,6 +3048,83 @@
}
/**
+ * 基础止盈：对基础仓位（baseQuantity）也挂止盈单，与超额止盈并行。
+ *
+ * <p>规则：从入场网格下一格（entryGridId ± 1）开始，每格 baseTakeProfitPerGrid 张，
+ * 最多挂 baseTakeProfitGridCount 格，挂到止损位前 2 格截止（即对手盘仓位线）。
+ *
+ * <p>边界：累计张数到 min(baseQuantity, 当前持仓) 即停（张数不足则最后一格挂剩余 = "挂几个算几个"）；
+ * 网格不足时挂到停止位置结束。
+ *
+ * @param posSize 当前总持仓张数
+ * @param isLong true=多仓止盈，false=空仓止盈
+ * @param entryGridId 入场网格 ID
+ */
+ private void placeBaseTakeProfit(int posSize, boolean isLong, int entryGridId) {
+ BigDecimal perGrid = config.getBaseTakeProfitPerGrid();
+ int gridCount = config.getBaseTakeProfitGridCount();
+ if (perGrid == null || perGrid.compareTo(BigDecimal.ZERO) <= 0 || gridCount <= 0) {
+ return;
+ }
+ int baseQty = Integer.parseInt(config.getBaseQuantity());
+ if (baseQty <= 0) {
+ return;
+ }
+ // 张数硬上限 = min(基础张数, 当前持仓)，避免持仓不足 baseQuantity 时超挂
+ int maxQty = Math.min(baseQty, posSize);
+ if (maxQty <= 0) {
+ return;
+ }
+
+ GridElement endElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
+ if (endElem == null) {
+ log.warn("[Gate] {}基础止盈失败：未找到对手盘止损位", isLong ? "多仓" : "空仓");
+ return;
+ }
+ int dir = isLong ? 1 : -1;
+ int startId = entryGridId + dir;
+ // 分配范围到止损位前 2 格截止（即对手盘仓位线）
+ int endId = endElem.getId() - 2 * dir;
+
+ BigDecimal remaining = BigDecimal.valueOf(maxQty);
+ int placed = 0;
+ int id = startId;
+ while (placed < gridCount && remaining.compareTo(BigDecimal.ZERO) > 0) {
+ if (isLong ? id > endId : id < endId) {
+ break;
+ }
+ GridElement elem = GridElement.findById(id);
+ if (elem == null) {
+ break;
+ }
+ BigDecimal qty = perGrid.min(remaining);
+ final GridElement fe = elem;
+ final int gid = id;
+ final BigDecimal triggerPrice = elem.getGridPrice();
+ 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;
+ executor.placeTakeProfit(triggerPrice, rule, orderType, size,
+ profitId -> {
+ if (isLong) {
+ longTakeProfitTraderIdParam(fe, profitId, true);
+ } else {
+ shortTakeProfitTraderIdParam(fe, profitId, true);
+ }
+ log.info("[Gate] 基础止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
+ isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
+ }
+ );
+ remaining = remaining.subtract(qty);
+ placed++;
+ id += dir;
+ }
+ log.info("[Gate] 基础止盈 {} 挂单完成, 入场gridId:{}, 挂{}格, 剩余{}张",
+ isLong ? "多仓" : "空仓", entryGridId, placed, remaining);
+ }
+
+ /**
* 在指定网格挂一笔对手止盈单（非满仓超额止盈，挂在止损触发位的下一格）。
*/
private void placeTakeProfitAtGrid(GridElement tpElem, boolean isLong, int qty, int times) {
--
Gitblit v1.9.1