【JAVA】利用Redisson和Spring实现高效物联温度控制链路，确保温度调节的准确性和效率，定时链路执行使用案例，一环扣一环

吃海的虾酱2024-06-27 15:56

主要功能和场景

  1. 柔性调温策略：这个类主要用于管理一个温度调节流程，通过不同的策略（如策略1和策略2）来调节温度，确保设备或环境中的温度达到预设的目标。

  2. 紧急停止机制：在流程执行过程中，如果需要紧急停止，可以通过设置一个标志来立即停止所有正在进行的任务。

  3. 定时任务管理 ：使用Java的ScheduledExecutorService来管理定时任务，如定期检查温度、执行特定的温度调节策略等。

  4. Redis集成：使用Redisson客户端与Redis数据库交互，存储和检索紧急停止的状态。

代码详细描述

  • 类结构：

    • 使用@Slf4j注解来自动生成日志记录器。
    • 使用@RequiredArgsConstructor注解来自动注入对象

  • 常量定义：

    • STRATEGY_DURATION：定义了策略的持续时间，这里是5分钟减去30秒。
    • EMERGENCY_STOPPED_KEY：在Redis中存储紧急停止状态的键。
    • EMERGENCY_STOPPED和RESTART_STOPPED：分别代表紧急停止和重启的状态。

  • 方法：

    • startProcessChain(Long planId)：启动整个流程，首先检查是否需要紧急停止，然后开始执行柔性调温策略1。
    • applyFlexibleTempStrategy1(Long planId)和applyFlexibleTempStrategy2(Long planId)：分别实现策略1和策略2，包括下发温度调节指令和召测命令，以及根据召测结果调整策略。
    • waitFor5MinutesAfterStrategy1(Long planId)和waitFor10MinutesAfterStrategy2(Long planId)：在策略1和策略2之后等待一定时间，然后执行下一步。
    • applyTargetPower(Long planId)：在策略2之后执行目标功率控制。
    • waitFor10MinutesBeforeStop(Long planId)：在停止前等待10分钟。
    • emergencyStop(Long planId)和restart(Long planId)：分别用于紧急停止流程和重启流程。
    • isEmergencyStopped(Long planId)和setEmergencyStopped(Long planId)：用于检查和设置紧急停止状态。

使用场景

这个类适用于需要精确控制温度的场景，如数据中心、实验室或工业生产环境，其中温度的精确控制对于设备的正常运行至关重要。通过这个流程管理器，可以确保在各种情况下都能有效地调节温度，同时提供紧急停止机制以应对突发情况。

在ProcessManager类中，每个流程都创建了一个ScheduledExecutorService实例，通过Executors.newScheduledThreadPool(1)创建了一个大小为1的线程池。这种设计有几个好处：

  1. 资源控制：通过限制线程池的大小为1，可以确保每个流程在其生命周期内只使用一个线程。这有助于防止资源过度消耗，特别是在高并发环境中，可以避免因创建过多线程而导致的系统资源耗尽。

  2. 任务串行执行：由于线程池大小为1，所有提交给该线程池的任务将按顺序串行执行。这意味着一个流程中的所有任务都是顺序执行的，不会并发执行，这有助于简化任务之间的同步和数据依赖问题。

  3. 简化同步：在某些情况下，流程中的任务可能需要访问共享资源或状态，串行执行可以减少或消除对这些资源进行复杂同步的需求，因为任务不会并发地访问这些资源。

  4. 避免竞态条件：在单线程环境中，不会出现竞态条件（race conditions），因为任务是按顺序执行的。这对于确保流程的正确性和可预测性非常重要。

  5. 易于管理 ：单线程池使得任务的管理和监控更加简单。例如，如果需要取消所有任务，只需调用scheduler.shutdown()即可。

  6. 适合定时任务 ：ScheduledExecutorService特别适合执行定时任务，如周期性任务或延迟任务。通过使用单线程池，可以确保这些任务按照预定的时间表执行，而不会因为线程争用而产生时间偏差。

总之，为每个流程创建一个单线程的ScheduledExecutorService可以提供一个简单、可控且高效的方式来管理流程中的定时任务，同时确保流程的稳定性和可预测性。

java 复制代码 
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.hutool.core.text.CharSequenceUtil;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 能力认定流程manager
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class ProcessManager {
    /**
     * 5分钟，单位为毫秒（策略持续时间），30秒执行一次，减少30秒是由于第一次进入默认执行一次召测
     */
    private static final long STRATEGY_DURATION = 5 * 60 * 1000 - 30000;

    /**
     * Redis中存储紧急停止值
     */
    private static final String EMERGENCY_STOPPED_KEY = "IOT:EMERGENCY:STOPPED:VAL:";

    /**
     * 紧急停止值
     */
    private static final String EMERGENCY_STOPPED = "1";

    /**
     * 重启
     */
    private static final String RESTART_STOPPED = "0";

    /**
     * Redisson客户端
     */
    private final RedissonClient redissonClient;

    /**
     * 启动任务
     */
    public void startProcessChain(Long planId) {
        // 否紧急停止
        if (isEmergencyStopped(planId)) {
            return;
        }

        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        log.info("Step 0 startProcessChain with task ID: " + planId);

        // 立即执行柔性调温策略1
        scheduler.schedule(() -> applyFlexibleTempStrategy1(planId), 0, TimeUnit.SECONDS);

        // 立马取消当前任务
        scheduler.shutdown();
    }

    /**
     * 柔性调温策略1
     */
    private void applyFlexibleTempStrategy1(Long planId) {
        // 紧急停止
        if (isEmergencyStopped(planId)) {
            return;
        }

        log.info("Step 1 下发遥调指令task ID: " + planId);

        // 下发遥调指令
        String tempValue = "18";

        // 下发遥调任务失败，流程结束
        if (packageCommandTempIssuance()) {
            return;
        }

        long startTime = System.currentTimeMillis();
        // 整个流程持续五分钟，30秒执行一次
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            // 紧急停止
            if (isEmergencyStopped(planId)) {
                return;
            }

            log.info("Step 1 下发召测命令 task ID: " + planId);
            int unConformNum = packageCallForTest();

            // 不满足数量=0时表示都满足18° ± 0.5°，立即执行下一步
            if (unConformNum == 0) {
                log.info("Step 1 策略1条件已满足，执行下一步等待 task ID: " + planId);
                // 满足条件立马执行:"等待五分钟"策略
                scheduler.schedule(() -> waitFor5MinutesAfterStrategy1(planId), 0, TimeUnit.SECONDS);
                // 立马取消当前任务
                scheduler.shutdown();
            }

            long elapsedTime = System.currentTimeMillis() - startTime;

            // 5分钟内所有通道温度未达到18° ± 0.5°，任务终止
            if (unConformNum != 0 && elapsedTime >= STRATEGY_DURATION) {
                log.info("Step 1 下发召测命令不满足要求:planId:{},不满足数量：{} ", planId, unConformNum);
                emergencyStop(planId);
                scheduler.shutdown();
            }
        }, 0, 30, TimeUnit.SECONDS);
    }

    /**
     * 柔性调温策略1之后等待五分钟：配置码值动态获取
     */
    private void waitFor5MinutesAfterStrategy1(Long planId) {
        // 紧急停止
        if (isEmergencyStopped(planId)) {
            return;
        }

        String value = "5";
        log.info("After step 1 waiting for " + value + " minutes for task ID: " + planId);
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        // 五分钟之后执行applyFlexibleTempStrategy2
        scheduler.schedule(() -> applyFlexibleTempStrategy2(planId), Long.parseLong(value),
                TimeUnit.MINUTES);

        // 立马取消当前任务
        scheduler.shutdown();
    }

    /**
     * 柔性调温策略2
     */
    private void applyFlexibleTempStrategy2(Long planId) {
        // 紧急停止
        if (isEmergencyStopped(planId)) {
            return;
        }

        log.info("Step 2 策略2下发遥调指令 task ID: " + planId);
        // 下发遥调指令
        String tempValue = "26";

        // 下发遥调任务失败，流程结束
        if (packageCommandTempIssuance()) {
            emergencyStop(planId);
            return;
        }

        long startTime = System.currentTimeMillis();
        // 整个流程持续五分钟
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            // 紧急停止
            if (isEmergencyStopped(planId)) {
                return;
            }

            log.info("Step 2 策略2下发召测指令 task ID: " + planId);
            int unConformNum = packageCallForTest();

            // 不满足数量=0时表示都满足26° ± 0.5°，立即执行下一步
            if (unConformNum == 0) {
                log.info("Step 2 策略2条件已满足，执行下一步等待 task ID: " + planId);
                // 满足条件立马执行:"等待五分钟"策略
                scheduler.schedule(() -> waitFor10MinutesAfterStrategy2(planId), 0, TimeUnit.SECONDS);

                // 立马取消当前任务
                scheduler.shutdown();
            }

            long elapsedTime = System.currentTimeMillis() - startTime;

            // 5分钟内所有通道温度未达到26° ± 0.5°，任务终止
            if (unConformNum != 0 && elapsedTime >= STRATEGY_DURATION) {
                log.info("Step 2 下发召测命令不满足要求:planId:{},不满足数量：{} ", planId, unConformNum);
                emergencyStop(planId);
                // 立马取消当前任务
                scheduler.shutdown();
            }
        }, 0, 30, TimeUnit.SECONDS);
    }

    /**
     * 柔性调温策略2之后等10分钟：配置码值动态获取
     */
    private void waitFor10MinutesAfterStrategy2(Long planId) {
        if (isEmergencyStopped(planId)) {
            return;
        }

        String value = "10";
        log.info("After step 2 Waiting for " + value + " minutes task: " + planId);
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        // 等10分钟目标功率控制
        scheduler.schedule(() -> applyTargetPower(planId), Long.parseLong(value), TimeUnit.MINUTES);

        // 立马取消当前任务
        scheduler.shutdown();
    }

    /**
     * 目标功率控制
     */
    private void applyTargetPower(Long planId) {
        if (isEmergencyStopped(planId)) {
            return;
        }

        log.info("Step 3 目标功率控制 task ID: " + planId);

        // 下发遥调任务失败，流程结束
        if (packageCommandTempIssuance()) {
            emergencyStop(planId);
            return;
        }
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        // 立即执行停止前等待10分钟
        scheduler.schedule(() -> waitFor10MinutesBeforeStop(planId), 0,
                TimeUnit.SECONDS);

        // 立马取消当前任务
        scheduler.shutdown();
    }

    /**
     * 停止前等待10分钟：配置码值动态获取
     */
    private void waitFor10MinutesBeforeStop(Long planId) {
        // 紧急停止
        if (isEmergencyStopped(planId)) {
            return;
        }

        String tempValue = "10";
        log.info("After step 3 wait for " + tempValue + " minutes task ID: " + planId);
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        scheduler.schedule(() -> {
            log.info("waitFor10MinutesBeforeStop step 4 stop task ID: " + planId);
            // 立马取消当前任务
            scheduler.shutdown();
        }, Long.parseLong(tempValue), TimeUnit.MINUTES);
    }

    /**
     * 紧急停止
     */
    public void emergencyStop(Long planId) {
        log.info("Emergency stopping the process with task ID: " + planId);
        setEmergencyStopped(planId);
    }

    /**
     * 重启一键能力认证流程
     */
    public void restart(Long planId) {
        // 1:true,0:false
        redissonClient.getBucket(EMERGENCY_STOPPED_KEY + planId).set(RESTART_STOPPED);
    }

    /**
     * 是否紧急停止
     */
    private boolean isEmergencyStopped(Long planId) {
        RBucket < String > bucket = redissonClient.getBucket(EMERGENCY_STOPPED_KEY + planId);
        String isEmergencyStopped = bucket.get();
        return isEmergencyStopped != null && CharSequenceUtil.equals(isEmergencyStopped, EMERGENCY_STOPPED);
    }

    /**
     * 设置紧急停止值
     */
    private void setEmergencyStopped(Long planId) {
        // 1:true,0:false
        redissonClient.getBucket(EMERGENCY_STOPPED_KEY + planId).set(EMERGENCY_STOPPED);
    }

    /**
     * 下发遥调指令
     */
    private boolean packageCommandTempIssuance() {
        // 下发遥调指令，示意代码
        return true;
    }

    /**
     * 下发召测命令
     *
     * @return 不满足数量
     */
    private Integer packageCallForTest() {
        // 下召测命令,拿内机数据，示意代码
        return 0;
    }
}
相关推荐
Tech Synapse2 分钟前
Java循环创建对象内存溢出怎么解决
java·开发语言·jvm
IT·陈寒3 分钟前
Kotlin vs Java：深入解析两者之间的最新差异与优劣（全面指南）
java·python·kotlin
行动π技术博客14 分钟前
spring中IOC相关介绍
java·spring·rpc
WHYBIGDATA19 分钟前
Scala中高级的函数编程
开发语言·后端·scala
吃青椒的小新24 分钟前
独一无二的设计模式——单例模式（Java实现）
java·后端·单例模式·设计模式
知识分享小能手24 分钟前
从新手到高手：Scala函数式编程完全指南，Scala 访问修饰符（6）
大数据·开发语言·后端·python·数据分析·scala·函数式编程
天才梦浪27 分钟前
开源租房项目
java·项目
杰哥在此41 分钟前
Java面试题：解释跨站脚本攻击（XSS）的原理，并讨论如何防范
java·开发语言·面试·编程·xss
蝎子莱莱爱打怪1 小时前
maven卸载旧版本3.1.0 并安装新版本3.8.8
后端
Czi橙1 小时前
玩玩快速冥(LeetCode50题与70题以及联系斐波那契)
java·算法·快速幂·斐波那契
热门推荐
01Coze扣子平台完整体验和实践（附国内和国际版对比）02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03【经验分享】Ubuntu22.04安装微信(linux官方版)04yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）052025张宇考研数学，百度网盘视频课+36讲PDF讲义+真题06【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解07升级 Ubuntu 主机上的 OpenSSH 从 8.9p1 到 9.8p108通达信神奇九转指标原理及选股公式，无未来函数，数字不消失09浏览器插件——ModHeader 的分享和学习10【漏洞复现】Geoserver远程代码执行漏洞（CVE-2024-36401）