simulation-backend/src/main/java/com/hivekion/room/bean/Room.java

package com.hivekion.room.bean;

import com.hivekion.Global;
import com.hivekion.baseData.entity.Scenario;
import com.hivekion.common.entity.ResponseCmdInfo;
import com.hivekion.common.utils;
import com.hivekion.common.uuid.IdUtils;
import com.hivekion.room.func.TaskAction;
import com.hivekion.scenario.bean.ScenarioWsParam;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.NavigableMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

/**
 * [类的简要说明]
 * <p>
 * [详细描述，可选]
 * <p>
 *
 * @author LiDongYU
 * @since 2025/7/22
 */
@Data
@Slf4j
public class Room implements AutoCloseable {

  /**
   * 任务管理相关
   */
  private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
  private ScheduledFuture<?> future;
  /**
   * 房间ID
   */
  private String roomId;
  /**
   * 想定信息
   */
  private Scenario scenario;
  /**
   * 任务容器
   */
  private NavigableMap<Long, Map<String, TaskAction>> actionMap = new ConcurrentSkipListMap<>();
  //日期格式化
  private DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  //线程池
  private final ExecutorService actionExecutor =
      new ThreadPoolExecutor(
          5, 5, // corePoolSize, maximumPoolSize
          0L, TimeUnit.MILLISECONDS,
          new LinkedBlockingQueue<>(1000), // 有界队列，只允许100个待执行任务
          new ThreadPoolExecutor.AbortPolicy() // 超出直接抛异常
      );

  public Room(String roomId, Scenario scenario) {
    this.roomId = roomId;
    this.scenario = scenario;
  }

  /**
   * 持续时间
   */
  private AtomicLong duringTime = new AtomicLong(0);
  private AtomicLong totalTime = new AtomicLong(0);

  private int mag = 1;



  /**
   * 启动
   *
   * @param time 总时间
   */
  public void start(long time) {

    totalTime.set(time);
    startTask();
  }

  /**
   * 停止
   */
  public void stop() {
    cancelTask();
  }

  /**
   * 暂停
   */
  public void pause() {
    cancelTask();
  }

  public void resume() {
    startTask();
  }

  public long getDuringTime() {
    return duringTime.get();
  }
  public long getTotalTime() {
    return totalTime.get();
  }

  // 启动定时任务
  private void startTask() {
    if (future == null || future.isCancelled()) {
      future = scheduler.scheduleAtFixedRate(() -> {
        ScenarioWsParam magValue = Global.roomParamMap.get(this.scenario.getId() + "_" + this.roomId);
        if(magValue!=null){
          this.mag = magValue.getMag();
        }

        long curTime = duringTime.addAndGet(this.mag);

        sendRemainTime((totalTime.get() - curTime));

        NavigableMap<Long, Map<String, TaskAction>> actions = actionMap.headMap(curTime, true);
        if (!actions.isEmpty() ) {
          actions.forEach((key, action) -> {
             action.forEach((taskAction, task) -> {
               actionExecutor.submit(task::doSomeThing);
             });
          });

          actions.clear();
        }
      }, 0, 1, TimeUnit.SECONDS);
    }
  }

  // 取消定时任务
  private void cancelTask() {
    if (future != null && !future.isCancelled()) {
      future.cancel(true);

    }
  }

  public void addAction(long time, TaskAction action) {
    actionMap.computeIfAbsent(time, k -> new ConcurrentHashMap<>())
        .put(IdUtils.simpleUUID(), action);

  }

  @Override
  public void close() throws Exception {
    actionMap.clear();
    if (future != null && !future.isCancelled()) {
      future.cancel(true);
    }
    if (scheduler != null && !scheduler.isShutdown()) {
      scheduler.shutdown();
    }
  }

  private void sendRemainTime(long remainTime) {

    Map<String, Object> timeMap =  new HashMap<>();
    timeMap.put("update_time_str",utils.formatSeconds(remainTime));
    timeMap.put("remain_time",remainTime);
    timeMap.put("during_time",duringTime.get());
    timeMap.put("current_time",df.format(this.scenario.getStartTime().plusSeconds(duringTime.get())));

    Global.sendCmdInfoQueue.add(
        ResponseCmdInfo.create("update_time", this.roomId, this.scenario.getId(),
            timeMap));
  }
}