首页 > 文章 > 前端

状态机是什么？有限状态机详解

时间：2025-08-17 17:39:55 229浏览收藏

状态机是什么？本文深入解析有限状态机的概念及其在软件开发中的应用。状态机作为一种数学模型，用于描述对象在不同状态间的转换，尤其有限状态机因其状态数量有限而在编程中被广泛采用，如游戏角色控制、网络协议解析和用户界面管理。文章重点介绍了几种常见的有限状态机实现方法，包括：简洁但难以维护的基于枚举和switch/case语句；通过封装状态类增强扩展性的状态模式；清晰表达转换规则但规模受限的状态转换表；以及功能强大的基于框架或库（如Spring Statemachine）的方法。选择哪种实现方式，需根据项目复杂度和需求进行权衡，以实现代码逻辑的优化和程序的可维护性与可扩展性。

有限状态机常见实现方式有：基于枚举和switch/case语句，适合简单场景但难以维护；状态模式通过封装状态类提升扩展性但类数量增多；状态转换表以表格形式清晰表达转换规则但规模大时复杂；基于框架或库如Spring Statemachine可支持高级功能。选择方式需根据复杂度和需求权衡。

什么是状态机？有限状态机的实现

状态机，简单来说，就是一种描述对象在不同状态之间转换的数学模型。它定义了一组状态、事件以及状态转换的规则。有限状态机（FSM）则意味着状态的数量是有限的。

状态机在软件开发中用途广泛，例如控制游戏角色的行为、解析网络协议、管理用户界面等等。理解状态机，能让你更好地组织代码逻辑，提高程序的可维护性和可扩展性。

状态机的核心在于定义清晰的状态和状态转换。

有限状态机的常见实现方式有哪些？

实现有限状态机的方法有很多，常见的包括：

基于枚举和switch/case语句： 这是最简单直接的方式。使用枚举类型定义状态，然后使用switch/case语句根据当前状态和输入事件来决定下一个状态。

enum State {
    IDLE,
    RUNNING,
    STOPPED
}

State currentState = State.IDLE;

void processEvent(Event event) {
    switch (currentState) {
        case IDLE:
            if (event == Event.START) {
                currentState = State.RUNNING;
                // 执行进入RUNNING状态的动作
                System.out.println("进入RUNNING状态");
            }
            break;
        case RUNNING:
            if (event == Event.STOP) {
                currentState = State.STOPPED;
                // 执行进入STOPPED状态的动作
                System.out.println("进入STOPPED状态");
            } else if (event == Event.PAUSE) {
                currentState = State.IDLE;
                System.out.println("进入IDLE状态");
            }
            break;
        case STOPPED:
            if (event == Event.RESET) {
                currentState = State.IDLE;
                // 执行进入IDLE状态的动作
                System.out.println("进入IDLE状态");
            }
            break;
    }
}

enum Event {
    START,
    STOP,
    RESET,
    PAUSE
}

public static void main(String[] args) {
    FiniteStateMachineExample fsm = new FiniteStateMachineExample();
    fsm.processEvent(Event.START);
    fsm.processEvent(Event.STOP);
    fsm.processEvent(Event.RESET);
}

这种方式的优点是简单易懂，但缺点是当状态数量增多时，switch/case语句会变得非常冗长，难以维护。

状态模式： 状态模式是一种设计模式，它将每个状态封装成一个独立的类，并定义一个上下文类来维护当前状态。当接收到事件时，上下文类将事件委托给当前状态对象处理。

// 状态接口
interface State {
    void handleEvent(Context context, Event event);
}

// 具体状态类
class IdleState implements State {
    @Override
    public void handleEvent(Context context, Event event) {
        if (event == Event.START) {
            System.out.println("Idle -> Running");
            context.setState(new RunningState());
        }
    }
}

class RunningState implements State {
    @Override
    public void handleEvent(Context context, Event event) {
        if (event == Event.STOP) {
            System.out.println("Running -> Stopped");
            context.setState(new StoppedState());
        } else if (event == Event.PAUSE) {
            System.out.println("Running -> Idle");
            context.setState(new IdleState());
        }
    }
}

class StoppedState implements State {
    @Override
    public void handleEvent(Context context, Event event) {
        if (event == Event.RESET) {
            System.out.println("Stopped -> Idle");
            context.setState(new IdleState());
        }
    }
}

// 上下文类
class Context {
    private State state;

    public Context() {
        this.state = new IdleState(); // 初始状态
    }

    public void setState(State state) {
        this.state = state;
    }

    public void processEvent(Event event) {
        this.state.handleEvent(this, event);
    }

    public State getState() {
        return state;
    }
}

enum Event {
    START,
    STOP,
    RESET,
    PAUSE
}

public class StatePatternExample {
    public static void main(String[] args) {
        Context context = new Context();
        context.processEvent(Event.START);
        context.processEvent(Event.STOP);
        context.processEvent(Event.RESET);
    }
}

状态模式的优点是结构清晰，易于扩展和维护。缺点是需要创建较多的类。

状态转换表： 状态转换表是一种将状态转换规则以表格形式存储的数据结构。表格的每一行代表一个状态，每一列代表一个事件，表格中的单元格则表示在当前状态下接收到该事件后要转换到的下一个状态。

import java.util.HashMap;
import java.util.Map;

enum State {
    IDLE,
    RUNNING,
    STOPPED
}

enum Event {
    START,
    STOP,
    RESET,
    PAUSE
}

public class StateTransitionTableExample {

    private State currentState;
    private Map> transitionTable;

    public StateTransitionTableExample() {
        currentState = State.IDLE;
        transitionTable = new HashMap<>();

        // 初始化状态转换表
        Map idleTransitions = new HashMap<>();
        idleTransitions.put(Event.START, State.RUNNING);
        transitionTable.put(State.IDLE, idleTransitions);

        Map runningTransitions = new HashMap<>();
        runningTransitions.put(Event.STOP, State.STOPPED);
        runningTransitions.put(Event.PAUSE, State.IDLE);
        transitionTable.put(State.RUNNING, runningTransitions);

        Map stoppedTransitions = new HashMap<>();
        stoppedTransitions.put(Event.RESET, State.IDLE);
        transitionTable.put(State.STOPPED, stoppedTransitions);
    }

    public void processEvent(Event event) {
        Map transitions = transitionTable.get(currentState);
        if (transitions != null && transitions.containsKey(event)) {
            State nextState = transitions.get(event);
            System.out.println("状态从 " + currentState + " 转换到 " + nextState + "，事件：" + event);
            currentState = nextState;
        } else {
            System.out.println("无效的事件 " + event + " 在状态 " + currentState + " 下");
        }
    }

    public static void main(String[] args) {
        StateTransitionTableExample fsm = new StateTransitionTableExample();
        fsm.processEvent(Event.START);
        fsm.processEvent(Event.STOP);
        fsm.processEvent(Event.RESET);
        fsm.processEvent(Event.PAUSE); // 无效事件示例
    }
}

使用状态转换表可以清晰地表达状态转换逻辑，易于修改和扩展。但是，当状态和事件数量较多时，状态转换表会变得非常庞大。