交易所/ok-jys.git

			@@ -17,7 +17,9 @@

			import java.math.BigDecimal;
			import java.math.RoundingMode;
			import java.util.ArrayList;
			import java.util.List;
			import java.util.Random;


			public abstract class AbstractGetDataJob implements Runnable {
			@@ -44,6 +46,8 @@

			public abstract String getName();

			// 在类中定义静态Random实例
			private static final Random random = new Random();

			public abstract void realtimeHandle(String symbols);

			@@ -52,46 +56,165 @@

			try {
			String symbol = realtime.getSymbol();
			Integer decimal = itemService.getDecimal(symbol);
			Integer decimal = itemService.getDecimal(symbol); // 虚拟币通常8位小数，需保留足够精度
			Item item = this.itemService.findBySymbol(symbol);
			BigDecimal currentValue = AdjustmentValueCache.getCurrentValue().get(symbol);
			AdjustmentValue delayValue = AdjustmentValueCache.getDelayValue().get(symbol);


			if (delayValue != null) {
			// 延时几次
			int frequency = (int) Arith.div(Arith.mul(delayValue.getSecond(), 1000.0D), this.interval);

			// K线场景专属参数（可根据周期动态调整）
			//int kLineCycle = getKLineCycle(symbol); // 获取K线周期（如1min=1, 5min=5）
			//double baseFluctuation = kLineCycle <= 1 ? 0.05 : 0.08; // 短周期（1min）±5%，长周期（5min）±8%
			double baseFluctuation = 0.1;
			int trendConsistencyRate = 70; // 70%概率保持与前一个值的波动方向一致（模拟趋势）
			int maxAdjacentFluctuation = 5; // 相邻值波动不超过前一个值的5%（避免视觉跳变）


			Integer frequency = AdjustmentValueCache.getFrequency().get(symbol);
			List<BigDecimal> preAllocationList = AdjustmentValueCache.getPreAllocationList().get(symbol);
			Integer currentIndex = AdjustmentValueCache.getCurrentAllocationIndex().get(symbol);
			// 新增：记录前一个值的波动方向（用于趋势一致性）
			List<Boolean> upDownTrend = AdjustmentValueCache.getUpDownTrend().getOrDefault(symbol, new ArrayList<>());

			if (frequency == null) {
			frequency = (int) Arith.div(Arith.mul(delayValue.getSecond(), 1000.0D), this.interval);
			AdjustmentValueCache.getFrequency().put(symbol, frequency);

			if (frequency > 1) {
			preAllocationList = new ArrayList<>(frequency);
			BigDecimal totalValue = delayValue.getValue();
			// 虚拟币精度高，中间计算保留decimal+4位（避免精度丢失）
			BigDecimal average = totalValue.divide(new BigDecimal(frequency), decimal + 4, RoundingMode.HALF_UP);
			BigDecimal sum = BigDecimal.ZERO;

			// 优化1：最后k个值分散偏差（k=频率的2%，最少5个，确保最后一根K线无异常）
			int lastK = Math.max(5, frequency / 50);
			int normalCount = frequency - lastK;

			// 优化2：前n-k个值——模拟真实行情波动（截断正态分布+趋势一致性）
			for (int i = 0; i < normalCount; i++) {
			BigDecimal randomValue;
			if (i == 0) {
			// 第一个值：在基础波动范围内随机
			randomValue = generateTruncatedGaussianValue(average, baseFluctuation, decimal + 4);
			} else {
			// 非第一个值：70%概率保持与前一个值的波动方向一致
			boolean lastUp = upDownTrend.get(i - 1);
			boolean keepTrend = Math.random() * 100 <= trendConsistencyRate;

			if (keepTrend) {
			// 保持趋势：上涨则继续涨（或小跌），下跌则继续跌（或小涨）
			if (lastUp) {
			// 前一个上涨：本次波动范围 [0, +baseFluctuation*1.2]（允许小回调）
			randomValue = generateDirectionalValue(average, 0, baseFluctuation * 1.2, decimal + 4);
			} else {
			// 前一个下跌：本次波动范围 [-baseFluctuation*1.2, 0]（允许小反弹）
			randomValue = generateDirectionalValue(average, -baseFluctuation * 1.2, 0, decimal + 4);
			}
			} else {
			// 反转趋势：正常基础波动
			randomValue = generateTruncatedGaussianValue(average, baseFluctuation, decimal + 4);
			}

			// 优化3：强约束相邻值波动——不超过前一个值的5%
			BigDecimal lastValue = preAllocationList.get(i - 1);
			BigDecimal maxAdjacent = lastValue.multiply(new BigDecimal(maxAdjacentFluctuation / 100.0))
			.setScale(decimal + 4, RoundingMode.HALF_UP);
			BigDecimal adjacentDiff = randomValue.subtract(lastValue).abs();
			if (adjacentDiff.compareTo(maxAdjacent) > 0) {
			randomValue = lastValue.add(
			adjacentDiff.divide(randomValue.subtract(lastValue), decimal + 4, RoundingMode.HALF_UP)
			.multiply(maxAdjacent)
			);
			}
			}

			preAllocationList.add(randomValue);
			sum = sum.add(randomValue);
			// 记录当前值的波动方向（与平均值对比）
			upDownTrend.add(randomValue.compareTo(average) > 0);
			}

			// 优化4：最后k个值——极小波动+偏差分散（确保最后一根K线平滑）
			BigDecimal remaining = totalValue.subtract(sum);
			BigDecimal avgLastK = remaining.divide(new BigDecimal(lastK), decimal + 4, RoundingMode.HALF_UP);
			for (int i = 0; i < lastK - 1; i++) {
			// 最后k-1个值：波动范围缩小到基础波动的1/3（±1.7%~2.7%）
			BigDecimal smallFluctValue = generateTruncatedGaussianValue(avgLastK, baseFluctuation / 3, decimal + 4);
			preAllocationList.add(smallFluctValue);
			sum = sum.add(smallFluctValue);
			upDownTrend.add(smallFluctValue.compareTo(avgLastK) > 0);
			}
			// 最后1个值：仅承担剩余微小偏差（波动≤基础波动的1/5）
			BigDecimal finalValue = totalValue.subtract(sum);
			BigDecimal maxFinalFluct = avgLastK.multiply(new BigDecimal(baseFluctuation / 5))
			.setScale(decimal + 4, RoundingMode.HALF_UP);
			if (finalValue.abs().compareTo(maxFinalFluct) > 0) {
			finalValue = maxFinalFluct.multiply(finalValue.signum() == 1 ? BigDecimal.ONE : BigDecimal.ONE.negate());
			// 若超出范围，反向微调前一个值（确保总和正确）
			BigDecimal prevLastValue = preAllocationList.get(preAllocationList.size() - 1);
			preAllocationList.set(preAllocationList.size() - 1, prevLastValue.add(totalValue.subtract(sum).subtract(finalValue)));
			}
			preAllocationList.add(finalValue);
			upDownTrend.add(finalValue.compareTo(avgLastK) > 0);

			// 缓存新增：波动方向列表（用于趋势一致性）
			AdjustmentValueCache.getPreAllocationList().put(symbol, preAllocationList);
			AdjustmentValueCache.getCurrentAllocationIndex().put(symbol, 0);
			AdjustmentValueCache.getUpDownTrend().put(symbol, upDownTrend);
			currentIndex = 0;
			}
			}

			// 后续分配逻辑（不变，仅需在清理缓存时移除upDownTrend）
			if (frequency <= 1) {
			// 单次分配逻辑
			if (currentValue == null) {
			AdjustmentValueCache.getCurrentValue().put(symbol, delayValue.getValue());
			AdjustmentValueCache.getCurrentValue().put(symbol, delayValue.getValue().setScale(decimal, RoundingMode.HALF_UP));
			} else {
			AdjustmentValueCache.getCurrentValue().put(symbol,
			delayValue.getValue().add(currentValue));
			currentValue.add(delayValue.getValue()).setScale(decimal, RoundingMode.HALF_UP));
			}

			if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
			item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
			itemService.saveOrUpdate(item);
			}
			AdjustmentValueCache.getDelayValue().remove(symbol);
			cleanUpKLineCache(symbol); // K线场景专属缓存清理
			} else {
			// 本次调整值
			BigDecimal currentValue_frequency = delayValue.getValue().divide(new BigDecimal(frequency), decimal, RoundingMode.HALF_UP);
			// 按预分配列表取值
			if (preAllocationList != null && currentIndex != null && currentIndex < preAllocationList.size()) {
			BigDecimal currentValue_frequency = preAllocationList.get(currentIndex)
			.setScale(decimal, RoundingMode.HALF_UP);

			if (currentValue == null) {
			AdjustmentValueCache.getCurrentValue().put(symbol, currentValue_frequency);
			} else {
			AdjustmentValueCache.getCurrentValue().put(symbol,
			currentValue.add(currentValue_frequency));
			}
			// 更新当前值（K线价格）
			if (currentValue == null) {
			AdjustmentValueCache.getCurrentValue().put(symbol, currentValue_frequency);
			} else {
			AdjustmentValueCache.getCurrentValue().put(symbol,
			currentValue.add(currentValue_frequency).setScale(decimal, RoundingMode.HALF_UP));
			}

			delayValue.setValue(delayValue.getValue().subtract(currentValue_frequency));
			delayValue.setSecond(Arith.sub(delayValue.getSecond(), Arith.div(this.interval, 1000.0D)));
			AdjustmentValueCache.getDelayValue().put(symbol, delayValue);
			// 更新延迟值和索引
			delayValue.setValue(delayValue.getValue().subtract(currentValue_frequency)
			.setScale(decimal, RoundingMode.HALF_UP));
			delayValue.setSecond(Arith.sub(delayValue.getSecond(), Arith.div(this.interval, 1000.0D)));
			AdjustmentValueCache.getDelayValue().put(symbol, delayValue);

			if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
			item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
			itemService.saveOrUpdate(item);
			int nextIndex = currentIndex + 1;
			AdjustmentValueCache.getCurrentAllocationIndex().put(symbol, nextIndex);

			// 分配完成，清理缓存
			if (nextIndex >= frequency) {
			cleanUpKLineCache(symbol);
			}

			// 保存K线数据更新
			if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
			item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
			itemService.saveOrUpdate(item);
			}
			}
			}
			}
			@@ -154,4 +277,55 @@
			this.dataDBService.saveAsyn(realtime);
			}



			// ------------------------------ 工具方法 ------------------------------
			/**
			* 生成截断正态分布值（限制在平均值±fluctuation范围内，模拟真实小波动）
			*/
			private BigDecimal generateTruncatedGaussianValue(BigDecimal average, double fluctuation, int scale) {
			double factor = nextGaussian() * 0.25; // 标准差0.25，99.7%概率在±0.75内（更集中）
			factor = Math.max(-1.0, Math.min(1.0, factor)); // 截断极端值
			BigDecimal fluctuationValue = average.multiply(new BigDecimal(factor * fluctuation))
			.setScale(scale, RoundingMode.HALF_UP);
			return average.add(fluctuationValue);
			}

			/**
			* 生成指定方向的波动值（如[0, +0.1]表示只涨不跌）
			*/
			private BigDecimal generateDirectionalValue(BigDecimal average, double minFactor, double maxFactor, int scale) {
			double factor = minFactor + Math.random() * (maxFactor - minFactor);
			BigDecimal fluctuationValue = average.multiply(new BigDecimal(factor))
			.setScale(scale, RoundingMode.HALF_UP);
			return average.add(fluctuationValue);
			}

			/**
			* K线场景专属缓存清理（含波动方向列表）
			*/
			private void cleanUpKLineCache(String symbol) {
			AdjustmentValueCache.getDelayValue().remove(symbol);
			AdjustmentValueCache.getFrequency().remove(symbol);
			AdjustmentValueCache.getPreAllocationList().remove(symbol);
			AdjustmentValueCache.getCurrentAllocationIndex().remove(symbol);
			AdjustmentValueCache.getUpDownTrend().remove(symbol); // 新增：清理波动方向缓存
			}

			/**
			* 获取K线周期（根据symbol或配置判断，示例返回1=1min，5=5min等）
			*/
			private int getKLineCycle(String symbol) {
			// 实际场景可从配置或symbol后缀获取（如BTC-USDT-1MIN → 1）
			return 1;
			}

			/**
			* 正态分布随机数生成（均值0，标准差1）
			*/
			private static double nextGaussian() {
			double u1 = Math.random();
			double u2 = Math.random();
			return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
			}
			}