状态机的理解和使用

最新推荐文章于 2024-08-27 21:25:37 发布
最新推荐文章于 2024-08-27 21:25:37 发布
阅读量1k 收藏 15
点赞数 9
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45792348/article/details/140675277
版权

问题引入

先来说一种现象，以订单状态举例，一个订单会有多种状态，待支付、取消支付、已支付待发货、待收货、待评价、已评价、已完成等等。每一种状态都和变化前的状态以及执行的操作有关。
比如待发货的前提条件是当前订单状态必须是已付款，才能更新状态为待发货，在这个过程中如果使用硬编码，我们就需要一系列的 if-else 语句来检查订单的当前状态、可执行操作以及这两个组合得到的下一个应该被流转的状态值。

// 场景一：监听到用户支付消息 
if (status == "待付款") { // 
    status == "已支付待发货" // 
}

// 场景二：用户进行下单 
if (用户进行下单) { // 
    status == "待支付" // 
    
}

上述的if-else会存在哪些问题呢？

  • 难以维护，上述的if-else可能存在各种地方，没有统一进行管理
  • 难以扩展，比如上述已支付待发货这种状态，需要拆分成已支付、待发货两种状态，可能需要修改的地方特别多，变更风险特别大
  • 可读性差，上述的if-else可能与其他业务逻辑耦合在一起，可读性变差

那有没有什么技术方案来解决这种问题呢？就是咱们接下来说的状态机

状态机

状态机（State Machine）是一种数学模型，用于描述对象或系统在不同状态之间的转移和行为。它由一组状态、转移条件和动作组成，可以根据输入条件从一个状态转移到另一个状态，并执行相应的动作。

相关概念

  • 状态（State） ：一个状态机至少要包含两个状态。如订单状态
  • 事件（Event） ：事件就是执行某个操作的触发条件或者口令。如支付时，订单状态由待付款变为待发货
  • 动作（Action） ：事件发生以后要执行动作。例如事件是“支付”，动作是“支付”。就会去执行支付相关逻辑
  • 转换（Transition） ：也就是从一个状态变化为另一个状态。
  • 守卫（Guard） ：一种条件逻辑，用于决定是否可以进行某个状态转换。守卫可以基于应用程序的当前状态或其他条件来确定转换是否应该发生。

特点

  • 离散性：状态机是离散的，它的状态和转移是离散的，不涉及连续变化。
  • 易于理解和建模：状态机可以直观地描述对象或系统的行为，使得人们能够更好地理解和建模复杂的逻辑。
  • 可扩展性：状态机可以轻松地添加新的状态和转移，以适应需求的变化。
  • 灵活性：状态机可以根据输入条件自动转移状态，并执行相应的动作，具有较高的灵活性和自动化能力。

总之，状态机是一种强大的工具，在一些较复杂的场景下可以帮助我们描述和管理对象或系统的状态和行为，提高代码的可理解性、可扩展性和灵活性。

状态机的实现

结合上述相关概率分析一下状态机图

状态机图六种元素：起始、终止、现态、次态（目标状态）、动作、条件

Spring Statemachine

引入依赖
<dependency>
  <groupId>org.springframework.statemachine</groupId>
  <artifactId>spring-statemachine-core</artifactId>
  <version>4.0.0</version>
</dependency>
创建订单实体类
/**
 * 订单实体类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
    // 订单id
    private String id;

    // 订单状态
    private OrderStatus status;
}
创建订单状态枚举类
/**
 * 订单状态
 */
public enum OrderStatus {
    // 待支付，待发货，待收货，已完成····
    WAIT_PAYMENT, 
    WAIT_DELIVER,
    WAIT_RECEIVE, 
    FINISH;
}
创建状态转换枚举类
public enum OrderStatusChangeEvent {
    // 支付，发货，确认收货
    PAYED, 
    DELIVERY, 
    RECEIVED;
}
添加状态流配置
@Configuration
@EnableStateMachine(name = "orderStateMachine") // 开启状态机，默认名称为stateMachine
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderStatusChangeEvent> {
    // 开发步骤
    // 1.继承StateMachineConfigurerAdapter,泛型为：state，event
    // 2.配置状态
    // 3.配置状态转换事件关系
    // 4.持久化配置

    /**
     * 配置状态
     *
     * @param stateConfigurer
     * @throws Exception
     */
    public void configure(StateMachineStateConfigurer<OrderStatus, OrderStatusChangeEvent> stateConfigurer) throws Exception {
        stateConfigurer
                .withStates()
                .initial(OrderStatus.WAIT_PAYMENT) // 初始状态
                // 也可以如下一次性配置状态
                // .states(EnumSet.allOf(OrderStatus.class))
                .state(OrderStatus.WAIT_DELIVER)
                .state(OrderStatus.WAIT_RECEIVE)
                .end(OrderStatus.FINISH); // 结束状态

    }

    /**
     * 配置状态转换事件关系
     *
     * @param transitionConfigurer
     * @throws Exception
     */
    public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderStatusChangeEvent> transitionConfigurer) throws Exception {
        transitionConfigurer
                // 这个函数是配置状态机的转换的，它用于指定转换是外部触发的。在状态机中，转换可以由内部事件或外部事件触发。使用withExternal()方法可以将转换配置为由外部事件触发。这意味着当外部事件发生时，状态机将根据配置的转换规则进行状态转换
                .withExternal()
                    // 可以通过source和target方法指定转换的源状态和目标状态。
                    .source(OrderStatus.WAIT_PAYMENT)
                    .target(OrderStatus.WAIT_DELIVER)
                    // 指定触发转换的事件
                    .event(OrderStatusChangeEvent.PAYED)
                .and()
                .withExternal()
                    .source(OrderStatus.WAIT_DELIVER)
                    .target(OrderStatus.WAIT_RECEIVE)
                    .event(OrderStatusChangeEvent.DELIVERY)
                .and()
                .withExternal()
                    .source(OrderStatus.WAIT_RECEIVE)
                    .target(OrderStatus.FINISH)
                    .event(OrderStatusChangeEvent.RECEIVED);
    }

    /**
     * 状态机持久化
     *
     * @return
     */
    @Bean
    public DefaultStateMachinePersister persister() {
        /**
         * DefaultStateMachinePersister是一个具体类，实现了StateMachinePersister接口，用于持久化状态机的状态。
         * 具体来说，它可能将状态信息存储在文件、数据库等介质中，以便在状态机重启或崩溃后能够恢复到之前的状态。
         * write方法用于将状态机上下文（StateMachineContext）和任意对象（Object o）写入持久化存储。
         * read方法用于从持久化存储中读取状态机上下文。
         */
        return new DefaultStateMachinePersister(new StateMachinePersist() {
            @Override
            public void write(StateMachineContext stateMachineContext, Object o) throws Exception {
                // 持久化到缓存或者数据库
            }

            @Override
            public StateMachineContext read(Object o) throws Exception {
                // 从缓存或者数据库中读取状态机
                return null;
            }
        });
    }
}
添加订单状态监听器
/**
 * 订单状态监听器
 */
@Component("orderStateListener")
// 关联指定状态机
@WithStateMachine(name = "orderStateMachine")
public class OrderStateListenerImpl {

    /**
     * 事件处理函数，用于处理订单状态从"WAIT_PAYMENT"到"WAIT_DELIVER"的转变
     * 在函数内部，可以对传入的事件消息进行处理，比如更新订单状态、发送通知等操作。
     * 根据业务逻辑的需要，函数可以执行一些判断、计算或者其他逻辑操作，以确定是否应该进行状态转换
     *
     * @param messge
     * @return
     */
    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    public boolean payTransition(Message<OrderStatusChangeEvent> messge) {
        Order order = (Order) messge.getHeaders().get("order");
        order.setStatus(OrderStatus.WAIT_DELIVER);
        System.out.println("订单支付成功，订单状态为：" + order.getStatus());
        return true;
    }

    @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
    public boolean deliverTransition(Message<OrderStatusChangeEvent> messge) {
        Order order = (Order) messge.getHeaders().get("order");
        order.setStatus(OrderStatus.WAIT_RECEIVE);
        System.out.println("订单发货成功，订单状态为：" + order.getStatus());
        return true;
    }

    @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
    public boolean receiveTransition(Message<OrderStatusChangeEvent> messge) {
        Order order = (Order) messge.getHeaders().get("order");
        order.setStatus(OrderStatus.FINISH);
        System.out.println("订单收货成功，订单状态为：" + order.getStatus());
        return true;
    }

}
OrderService接口
public interface OrderService {
    //创建订单
    Order create(Order order);
 
    //发起支付
    Order pay(String id);
 
    //订单发货
    Order deliver(String id);
 
    //订单收货
    Order receive(String id);
 
    //获取所有订单信息
    Map<String, Order> getOrders();
}
Service实现类
/**
 * 订单实现类
 */
@Service("orderService")
public class OrderServiceImpl implements OrderService {

    @Resource
    StateMachine<OrderStatus, OrderStatusChangeEvent> orderStatusMachine;

    @Resource
    StateMachinePersister<OrderStatus, OrderStatusChangeEvent, Order> stateMachinePersister;

    // 想象成数据库
    Map<String, Order> orderMap = new HashMap<>();

    /**
     * 创建订单
     *
     * @param order
     * @return
     */
    @Override
    public Order create(Order order) {
        order.setStatus(OrderStatus.WAIT_PAYMENT);
        orderMap.put(order.getId(), order);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行创建，订单信息" + order);
        return order;
    }

    /**
     * 订单支付
     *
     * @param id
     * @return
     */
    @Override
    public Order pay(String id) {
        Order order = orderMap.get(id);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行支付，订单信息" + order);
        Message<OrderStatusChangeEvent> message = MessageBuilder.withPayload(OrderStatusChangeEvent.PAYED).setHeader("order", order).build();
        if (!sendEvent(message,order)) {
            System.out.println("线程名称："+Thread.currentThread().getName() + "支付失败，状态异常，订单信息" + order);
        }
        return order;
    }

    /**
     * 订单发货
     *
     * @param id
     * @return order
     */
    @Override
    public Order deliver(String id) {
        Order order = orderMap.get(id);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行发货，订单信息" + order);
        Message<OrderStatusChangeEvent> message = MessageBuilder.withPayload(OrderStatusChangeEvent.DELIVERY).setHeader("order", order).build();
        if (!sendEvent(message,order)) {
            System.out.println("线程名称："+Thread.currentThread().getName() + "发货失败，状态异常，订单信息" + order);
        }
        return order;
    }

    /**
     * 订单收货
     *
     * @param id
     * @return order
     */
    @Override
    public Order receive(String id) {
        Order order = orderMap.get(id);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行收货，订单信息" + order);
        Message<OrderStatusChangeEvent> message = MessageBuilder.withPayload(OrderStatusChangeEvent.RECEIVED).setHeader("order", order).build();
        if (!sendEvent(message,order)) {
            System.out.println("线程名称："+Thread.currentThread().getName() + "收货失败，状态异常，订单信息" + order);
        }
        return order;
    }

    /**
     * 获取所有订单
     *
     * @return orderMap
     */
    @Override
    public Map<String, Order> getOrders() {
        return orderMap;
    }


    /**
     * 发送事件
     * 使用重量级锁来保证线程安全
     * 
     * @param message
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(Message<OrderStatusChangeEvent> message, Order order) {
        boolean result = false;
        try {
            // 显式开启
            orderStatusMachine.start();
            // 尝试恢复状态机状态
            // stateMachinePersister.restore(orderStatusMachine, order);
            // 添加延迟用户线程安全测试
            Thread.sleep(10000);
            // 发送事件，进行状态的变化
            result = orderStatusMachine.sendEvent(message);
            // 持久化状态机状态
            // stateMachinePersister.persist(orderStatusMachine, order);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
           // orderStatusMachine.stop();
        }
        return result;
    }
}
编写客户端测试代码
@SpringBootApplication
@ComponentScan(basePackages = "com.xww")
public class SpringMachineApplication {

    public static void main(String[] args) throws InterruptedException {
        Thread.currentThread().setName("主线程");
        ConfigurableApplicationContext context = SpringApplication.run(SpringMachineApplication.class, args);
        OrderService orderService = (OrderService) context.getBean("orderService");
        Order order1 = new Order();
        order1.setId("001");
        orderService.create(order1);
        orderService.pay(order1.getId());
        orderService.deliver(order1.getId());
        orderService.receive(order1.getId());
    }

}
控制台打印信息

image.png

Spring Statemachine的问题
  • stateMachine无法抛出异常，异常会被状态机给消化掉，从orderStateMachine.sendEvent(message);获取的结果无法感知到。无论执行正常还是抛出异常，都返回true。
  • 在并发环境中，多个线程可能同时尝试修改状态机的状态，这可能导致数据不一致或竞态条件（线程不安全）。

Cola-StateMachine

概述

Cola-StateMachine 是阿里云团队开源的一款轻量级、高性能的状态机框架，用于解决业务流程中状态流转的控制问题。
它基于无状态化设计，支持事件驱动和分布式事务，适用于构建复杂且高并发的状态机模型。它的主要特点是无状态、采用纯Java实现，使用Fluent Interface（连贯接口）来定义状态和事件，适用于管理状态转换的场景，如订单状态、支付状态等简单有限状态场景。Cola-StateMachine可以帮助开发者方便地管理业务对象的状态转换，提高开发效率。

Cola-StateMachine 和其他开源状态机框架最大的一个亮点，就在于解决了性能问题，将状态机变成无状态的。因为有状态的状态机需要

Cola-StateMachine为什么是无状态的？
首先，我们得知道，为什么其他开源状态机是有状态的，那是因为状态机内部维护了两个状态：初始状态与当前状态。因为这些状态机需要依靠这两个状态来做出决策。
但是Cola-StateMachine将这两个状态移除了，也就导致无法获取状态机的初始状态与当前状态。但是实际上我们也并不需要知道，只需要接收目标的状态，然后检查条件，解决执行事件即可，然后返回目标状态，然后根据目标状态更新Order状态即可。
这其实就是一个状态流转的DSL表达式，全过程都是无状态的。
而我们的系统往往是分布式多线程的，所以为了解决线程安全问题，我们不得不每次都要build一个实例。这就会导致了性能有所下降。

使用
引入依赖：
<dependency>
    <groupId>com.alibaba.cola</groupId>
    <artifactId>cola-component-statemachine</artifactId>
    <version>4.3.1</version>
</dependency>
copy上述的枚举类和实体类，及其service接口
编写配置类
@Configuration
@Slf4j
public class ColaStatemachineConfig {

    @Bean
    public StateMachine<OrderStatus, OrderStatusChangeEvent, Order> orderStatemachine() {
        String ORDER_STATE_MACHINE = "orderStateMachine";
        // 生成一个状态机builder
        StateMachineBuilder<OrderStatus, OrderStatusChangeEvent, Order> builder = StateMachineBuilderFactory.create();
        /**
         * 生成一个状态机builder，并定义了一个外部转换（externalTransition）。
         * 该转换是从OrderStatus.WAIT_PAYMENT状态到OrderStatus.WAIT_DELIVER状态，
         * 当发生OrderStatusChangeEvent.PAYED事件时触发。
         * 触发转换的条件是调用checkCondition()方法返回true，
         * 执行的动作是调用doAction()方法。
         */
        builder.externalTransition()
                .from(OrderStatus.WAIT_PAYMENT)
                .to(OrderStatus.WAIT_DELIVER)
                .on(OrderStatusChangeEvent.PAYED)
                .when(checkCondition())
                .perform(doAction());

        builder.externalTransition()
                .from(OrderStatus.WAIT_DELIVER)
                .to(OrderStatus.WAIT_RECEIVE)
                .on(OrderStatusChangeEvent.DELIVERY)
                .when(checkCondition())
                .perform(doAction());

        builder.externalTransition()
                .from(OrderStatus.WAIT_DELIVER)
                .to(OrderStatus.FINISH)
                .on(OrderStatusChangeEvent.DELIVERY)
                .when(checkCondition())
                .perform(doAction());

        // 创建状态机
        StateMachine<OrderStatus, OrderStatusChangeEvent, Order> orderStatusMachine = builder.build(ORDER_STATE_MACHINE);
        String uml = orderStatusMachine.generatePlantUML();
        log.info("{}",uml);
        return orderStatusMachine;
    }

    private Condition<Order> checkCondition() {
        return (ctx) -> {
            log.info("checkCondition:{}", JSONObject.toJSONString(ctx));
            return true;
        };
    }

    private Action<OrderStatus, OrderStatusChangeEvent, Order> doAction() {
        return (from, to, event, order) -> {
            log.info(" 正在操作 " + order.getId() + " from:" + from + " to:" + to + " on:" + event);
            // 获取当前订单状态
            OrderStatus status = order.getStatus();
            // 校验状态是否合法
            if (!status.equals(from)) {
                throw new RuntimeException("状态不合法");
            }
        };
    }
}
编写Service接口实现
/**
 * 订单实现类
 */
@Service("orderService")
@Slf4j
public class OrderServiceImpl implements OrderService {

    @Resource
    StateMachine<OrderStatus, OrderStatusChangeEvent, Order> orderStateMachine;

    // 想象成数据库
    Map<String, Order> orderMap = new HashMap<>();

    /**
     * 创建订单
     *
     * @param order
     * @return
     */
    @Override
    public Order create(Order order) {
        order.setStatus(OrderStatus.WAIT_PAYMENT);
        orderMap.put(order.getId(), order);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行创建，订单信息" + order);
        return order;
    }

    /**
     * 订单支付
     *
     * @param id
     * @return
     */
    @Override
    public Order pay(String id) {
        Order order = orderMap.get(id);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行支付，订单信息" + order);
        order = orderOperation(id, OrderStatus.WAIT_PAYMENT, OrderStatusChangeEvent.PAYED);
        return order;
    }

    /**
     * 订单发货
     *
     * @param id
     * @return order
     */
    @Override
    public Order deliver(String id) {
        Order order = orderMap.get(id);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行发货，订单信息" + order);
        order = orderOperation(id, OrderStatus.WAIT_DELIVER, OrderStatusChangeEvent.DELIVERY);
        return order;
    }

    /**
     * 订单收货
     *
     * @param id
     * @return order
     */
    @Override
    public Order receive(String id) {
        Order order = orderMap.get(id);
        System.out.println("线程名称："+Thread.currentThread().getName() + "进行收货，订单信息" + order);
        order = orderOperation(id, OrderStatus.WAIT_RECEIVE, OrderStatusChangeEvent.RECEIVED);
        return order;
    }

    /**
     * 获取所有订单
     *
     * @return orderMap
     */
    @Override
    public Map<String, Order> getOrders() {
        return orderMap;
    }


    /**
     * 发送事件
     *
     * @return
     */
    private Order orderOperation(String id, OrderStatus orderStatus, OrderStatusChangeEvent orderStatusChangeEvent) {
        String machineId = orderStateMachine.getMachineId();
        log.info("订单状态机：{}", machineId);
        Order order = orderMap.get(id);
        OrderStatus orderStatus1 = orderStateMachine.fireEvent(orderStatus, orderStatusChangeEvent, order);
        log.info("订单状态:{}", orderStatus1);
        order.setStatus(orderStatus1);
        // 更新
        orderMap.put(id, order);
        return order;
    }
}
测试代码
@SpringBootApplication
public class ColaStatemachineApplication {

    public static void main(String[] args) {
        Thread.currentThread().setName("主线程");
        ConfigurableApplicationContext context = SpringApplication.run(ColaStatemachineApplication.class, args);
        OrderService orderService = (OrderService) context.getBean("orderService");
        Order order1 = new Order();
        order1.setId("001");
        orderService.create(order1);
        orderService.pay(order1.getId());
        new Thread(() -> {
            orderService.deliver(order1.getId());
            orderService.receive(order1.getId());
        },"客户线程");
        orderService.deliver(order1.getId());
        orderService.receive(order1.getId());
        orderService.pay(order1.getId());
    }

}
执行结果

image.png

参考文档

xww86
关注
C# 状态机实现
01-04
C# 状态机实现 ，参考基于特定领域实现，还有待完善，进一步研究
搞懂状态机，看这一篇就够了
qq_59622162的博客
03-31 1990
详述状态机的具体功能用途，以及企业实战中可能会遇到的问题
什么是状态机
最新发布
m0_57836225的博客
08-27 590
当需要添加新的状态或事件时，只需要在状态机中定义新的状态和转换规则，而不需要对整个系统进行大规模的修改。- 在状态 S1，如果遇到“a”，转换到状态 S0（因为两个“a”后回到初始状态，认为“a”的数量又是偶数个）；- 在每一次转换中，计算下一个斐波那契数 `c = a + b`，然后更新状态为 `a = b`，`b = c`。- “出货中”状态完成后，如果需要找零，转换为“找零中”状态；这是一个典型的有限状态机，状态数量有限，并且状态转换是明确的，由特定的事件（如顾客操作、货币投入等）触发。
状态机实现-使用状态设计模式，使用场景
jagger的专栏
08-18 635
原理：使用的是设计模式中的状态模式。 优点：利于扩展，写更多的状态也没问题，不用各种ifelse的条件判断，缺点：需要每个状态写一个类 假设我都我有一个订单，其中有几个状态：下单、配送、完成 我要严格控制这几个状态的变更、环节日志的记录、任务日志的记录等，当然还可以有别的操作，比如发短信 订单状态 public interface OrderState { /** * 已下单 */ String PLACED = "order_placed"; /...
一文看懂什么是状态机
十年饮冰，难凉热血，保持热爱，奔赴星海！
08-01 1万+
状态机（State Machine）是一种数学模型，用于描述系统或程序在不同状态之间转换的行为。它由一组状态、转移条件和动作组成。提示：以下是本篇文章正文内容，下面案例可供参考状态机可以被看作是一个抽象的机器，它可以处于不同的状态，并根据输入条件执行相应的动作来改变状态。状态表示了系统或程序所处的特定情况或阶段，而转移条件决定了在何种条件下从一个状态转移到另一个状态，动作则表示在状态转移时要执行的操作。
状态机详解（一段式、二段式、三段式）
热门推荐
Jackiezhang1993的博客
12-26 4万+
一、有限状态机FSM（Finite State Machine） 组成元素： 输入、状态、状态转移条件、输出。 可以分为两类： Mealy状态机：时序逻辑的输出不仅取决于当前状态，还与输入有关； Moore状态机：时序逻辑的输出只与当前状态有关。 描述方式： ① 状态转移图：设计分析时使用，工具自动翻译的代码效率不...
什么是状态机？用C语言实现进程5状态模型
一口Linux的专栏
10-13 1万+
前言 状态机在实际工作开发中应用非常广泛，一口君曾经做过很多网络协议模块，可以说很多协议的开发都必须用到状态机；一个健壮的状态机可以让你的程序，不论发生何种突发事件都不会突然进入一个不可预知的程序分支，本篇通过实现一个简单的进程5状态模型的状态机，让大家熟悉一下状态机的魅力。 定义 有限状态机（finite-state machine，缩写FSM），又叫有限状态机自动机，简称状态机。是能够表示有限个状态以及这些状态之间的转移和动作等行为的数学模型。在计算机科学中，有限状态机被广泛用于建模应用行为、硬件电路系
什么是状态机？一篇文章就够了
坚持
08-11 2886
状态机
深入浅出理解有限状态机
02-24
在计算机科学中，有限状态机被广泛用于建模应用行为、硬件电路系统设计、软件工程，编译器、网络协议、和计算与语言的研究。比如下图非常有名的TCP协议状态机。其实我们在编程时实现相关业务逻辑时经常需要处理各种...
单片机多按键状态机的实现
07-05
7. 多按键处理：对于多个按键，可以使用独立的按键状态机，也可以用一个统一的状态机处理。后者通常需要考虑按键冲突问题，例如使用扫描码矩阵或编码算法避免同时按下多个按键时的误判。 8. 优化：可以引入消抖电路...
标准状态机_状态机_
10-03
1. 状态图：使用图形工具绘制状态机，清晰地展示状态、转换、事件和动作。 2. 状态表：以表格形式列出状态、事件、条件和动作，方便编程实现。 3. UML状态图：统一建模语言中的状态图，提供了标准化的符号和约定，...
LabViewJKI状态机
06-19
- **清晰的代码结构**：状态机的分层设计使得代码组织有序，易于理解和维护。 - **可扩展性**：容易添加新的状态和功能，而不影响现有代码。 - **并发执行**：支持多个子状态机并行运行，提高程序效率。 - **...
状态机(有限状态自动机 FSM)介绍以及常用状态机种类对比
黄嚯嚯
10-20 7818
状态机概念, 为什么要使用状态机
第六章：状态机
houyiming
10-15 3082
状态机的执行描述状态机可能采取的步骤构成的序列。**定义6.2.4：**状态机的执行是指状态机可能具有的状态序列(可能是无限的),满足以下性质1.从初始状态开始，并且2.若q, r表示序列中两个连续的状态，那么q →r。执行中出现的状态是可达的( reachable )。状态机的保持不变性是指关于状态的谓词P满足:对任意状态q，如果P(q)为真，且存在状态r，其中q →r，那么P®也为真。如果状态机的保持不变性在初始状态为真，则所有可达状态皆为真。
浅谈状态机
weixin_46075497的博客
05-11 3687
一、状态机原理 （一）有限状态机 状态机由状态寄存器和组合逻辑电路构成，能够根据控制信号按照预先设定的状态进行状态转移，是协调相关信号动作、完成特定操作的控制中心。有限状态机简写为FSM（Finite State Machine），主要分为2大类：Moore状态机和Mealy状态机 （二）Moore状态机 摩尔状态机:当输出(output)只与当前状态有关时，所描述的状态机称为Moore型状态机。 （三）Mealy状态机 米利状态机:当输出(output)不仅与当前状态有关而且与输入(inputs)有关时
状态机简介：理解和实现编程中的状态转换
fudaihb的博客
04-23 4652
状态机（State Machine）是一种数学模型和计算机科学中的抽象概念，它描述了对象在其生命周期中的状态如何根据输入或事件而转换。简单来说，状态机是一个可以表示对象状态及其状态之间转换的框架或图形表示。 在日常生活和软件开发中，我们经常会遇到需要管理和跟踪对象或系统状态的情况。例如，自动售货机、电梯控制系统、游戏角色状态等都可以通过状态机来清晰、高效地描述和管理。
什么是状态机（Finite-state machine）？
JMW1407的博客
09-12 4万+
有限状态机有限状态机(FSM)1、 什么是“状态”2、什么是状态机？3、状态机图怎么画？参考 有限状态机(FSM) 1、 什么是“状态” 先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed 。 状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换
状态机（state machine）
weixin_41458037的博客
01-14 6134
一、状态机分类 Mealy状态机：输出取决于输入和当前状态 状态寄存器：由一组触发器组成，用来记忆状态机当前所处的状态，状态的改变只发生在时钟的跳变沿。状态寄存器由一组触发器组成，用来记忆状态机当前所处的状态，状态的改变只发生在时钟的跳变沿。 状态是否改变、如何改变，取决于组合逻辑F的输出，F是当前状态和输入信号的函数。 状态机的输出是由输出组合逻辑G提供的，G也是当前状态和输入信号的函数...
udp unconn状态是监听状态么
07-16
UDP的Unconnected状态并不是监听状态，而是指在UDP通信中的一种状态。 在UDP通信中，UDP套接字可以处于三种状态：Unconnected、Connected和Bound。 - Unconnected状态：此时UDP套接字没有与特定的目标地址和端口连接，也没有绑定到本地地址和端口。可以通过该套接字发送和接收UDP数据报，但不会对通信进行任何连接管理。 - Connected状态：此时UDP套接字与特定的目标地址和端口建立了连接。只能与该目标地址和端口进行通信，其他地址和端口的数据将被丢弃。连接建立后，可以通过该套接字发送和接收UDP数据报，并能对通信进行一定程度的连接管理。 - Bound状态：此时UDP套接字绑定到本地地址和端口，但没有与特定的目标地址和端口建立连接。可以通过该套接字发送和接收UDP数据报，但不会对通信进行连接管理。 因此，Unconnected状态表示UDP套接字没有建立连接，可以在不绑定本地地址和端口的情况下进行通信。而监听状态是指TCP通信中的一种状态，用于等待其他主机发起连接请求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值