Go中的有限状态机FSM的详细介绍

1、FSM简介

1.1 有限状态机的定义

有限状态机（Finite State Machine，FSM）是一种数学模型，用于描述系统在不同状态下的行为和转移条件。
状态机有三个组成部分：状态（State）、事件（Event）、动作（Action），事件（转移条件）触发状态的转移和动作的执行。动作的执行不是必须的，可以只转移状态，不指定任何动作。总体而言，状态机是一种用以表示有限个状态以及这些状态之间的转移和动作的执行等行为的数学模型。
状态机可以用公式 State(S) , Event(E) -> Actions (A), State(S’)表示，即在处于状态S的情况下，接收到了事件E，使得状态转移到了S’，同时伴随着动作A的执行。

Event（事件）是指触发状态转换的输入信号或条件。它可以是任何类型的输入，例如传感器数据、用户输入、网络消息等。在编程中，Event通常是一个枚举类型，每个枚举值代表一个特定的事件。
State（状态）是指系统在某一时刻所处的状态，它是系统的一种抽象描述。在有限状态机中，状态是由一组状态变量来描述的，这些状态变量的取值决定了系统的状态。状态可以是离散的，也可以是连续的。在有限状态机中，状态通常用一个圆圈来表示，圆圈内部写上状态的名称。例如，一个简单的有限状态机可以有两个状态：开和关，它们可以用以下方式表示：

Action（动作）是指在状态转移时执行的操作或动作。当有限状态机从一个状态转移到另一个状态时，可以执行一个或多个action来改变系统的状态或执行某些操作。例如，当有限状态机从“待机”状态转移到“运行”状态时，可以执行一个action来启动系统。在实际应用中，action可以是任何有效的代码，例如函数调用、变量赋值、打印输出等。
FSM 通常用于编程中，用于实现状态转移和控制流程。
注意：

在任何时刻，FSM 只能处于一种状态。

1.2 Go中的FSM

通过上面关于有限状态机的定义，我们大概知道了状态机是个什么东西，那么Golang中是怎么实现的呢。不用慌，已经有大佬实现好了，只管用就好了。
安装：

1. go get github.com/looplab/fsm@v1.0.1

复制代码

接下来一起看看github.com/looplab/fsm 是如何使用的。
2、github.com/looplab/fsm 如何使用

注意：

不同版本的 fsm 使用方式，可能不太一样，最好是看下 NewFSM 函数的注释，看下具体的细节。 本篇文章以：github.com/looplab/fsm@v1.0.1 为例。

2.1 fsm 基础使用

这里把官方的例子改了下，感觉官方的例子不是很清晰。代码如下：

1. package main
3. import (
4.         "context"
5.         "fmt"
7.         "github.com/looplab/fsm"
8. )
10. type Door struct {
11.         Name  string
12.         FSM *fsm.FSM
13. }
15. func NewDoor(name string) *Door {
16.         d := &Door{
17.                 Name: name,
18.         }
20.         d.FSM = fsm.NewFSM(
21.                 "closed",
22.                 fsm.Events{
23.                         {Name: "open", Src: []string{"closed"}, Dst: "open"},
24.                         {Name: "close", Src: []string{"open"}, Dst: "closed"},
25.                 },
26.                 fsm.Callbacks{
27.                         "enter_state": func(_ context.Context, e *fsm.Event) { d.enterState(e) },
28.                 },
29.         )
31.         return d
32. }
34. func (d *Door) enterState(e *fsm.Event) {
35.         fmt.Printf("The door's name:%s , current state:%s\n", d.Name, e.Dst)
36. }
38. func main() {
39.         door := NewDoor("测试")
41.         fmt.Printf("fsm current state: %s \n", door.FSM.Current())
43.         err := door.FSM.Event(context.Background(), "open")
44.         if err != nil {
45.                 fmt.Println(err)
46.         }
47.         fmt.Printf("fsm current state: %s \n", door.FSM.Current())
49.         err = door.FSM.Event(context.Background(), "close")
50.         if err != nil {
51.                 fmt.Println(err)
52.         }
53.         fmt.Printf("fsm current state: %s \n", door.FSM.Current())
54. }

复制代码

执行结果：

1. fsm current state: closed
2. The door's name:测试 , current state:open
3. fsm current state: open
4. The door's name:测试 , current state:closed
5. fsm current state: closed

复制代码

这里就通过Event改变FSM中的状态。转移公式为：Src，Event -> Dst，d.enterState。大意就是接受到了输入Event，状态机的State由Src->Dst，并且执行了Action：d.enterState。
2.2 fsm 中 Action 何时执行？

刚开始使用的时候，好奇d.enterState(e)是什么时候调用的，我们一起看看 NewFSM 中的注释就清楚了。

1. // NewFSM constructs a FSM from events and callbacks.
2. //
3. // The events and transitions are specified as a slice of Event structs
4. // specified as Events. Each Event is mapped to one or more internal
5. // transitions from Event.Src to Event.Dst.
6. // Callbacks are added as a map specified as Callbacks where the key is parsed
7. // as the callback event as follows, and called in the same order:
8. //
9. // 1. before_<EVENT> - called before event named <EVENT>
10. //
11. // 2. before_event - called before all events
12. //
13. // 3. leave_<OLD_STATE> - called before leaving <OLD_STATE>
14. //
15. // 4. leave_state - called before leaving all states
16. //
17. // 5. enter_<NEW_STATE> - called after entering <NEW_STATE>
18. //
19. // 6. enter_state - called after entering all states
20. //
21. // 7. after_<EVENT> - called after event named <EVENT>
22. //
23. // 8. after_event - called after all events
24. //
25. // There are also two short form versions for the most commonly used callbacks.
26. // They are simply the name of the event or state:
27. //
28. // 1. <NEW_STATE> - called after entering <NEW_STATE>
29. //
30. // 2. <EVENT> - called after event named <EVENT>
31. //
32. // If both a shorthand version and a full version is specified it is undefined
33. // which version of the callback will end up in the internal map. This is due
34. // to the pseudo random nature of Go maps. No checking for multiple keys is
35. // currently performed.

复制代码

从上面我们知道了，d.enterState(e) 是在called after entering all states 时执行的。
2.2.1 完整版书写的Callbacks执行顺序

从上面的注释能知道完整版书写的Callbacks的执行顺序如下:

2.2.2 简写版的Callbacks执行顺序


2.2.3 注意事项

虽然Callbacks的写法有两种，但是不能同时使用完整版和简写版，否则最终使用那个版本是不确定的。
2.3 较为完整的例子

1. package main
3. import (
4.         "context"
5.         "fmt"
7.         "github.com/looplab/fsm"
8. )
10. type Door struct {
11.         Name  string
12.         FSM *fsm.FSM
13. }
15. func NewDoor(name string) *Door {
16.         d := &Door{
17.                 Name: name,
18.         }
20.         d.FSM = fsm.NewFSM(
21.                 "closed",
22.                 fsm.Events{
23.                         {Name: "open", Src: []string{"closed"}, Dst: "open"},
24.                         {Name: "close", Src: []string{"open"}, Dst: "closed"},
25.                 },
26.                 fsm.Callbacks{
27.                         "before_open": func(_ context.Context, e *fsm.Event) { d.beforeOpen(e) },
28.                         "before_event": func(_ context.Context, e *fsm.Event) { d.beforeEvent(e) },
29.                         "leave_closed": func(_ context.Context, e *fsm.Event) { d.leaveClosed(e) },
30.                         "leave_state": func(_ context.Context, e *fsm.Event) { d.leaveState(e) },
31.                         "enter_open": func(_ context.Context, e *fsm.Event) { d.enterOpen(e) },
32.                         "enter_state": func(_ context.Context, e *fsm.Event) { d.enterState(e) },
33.                         "after_open": func(_ context.Context, e *fsm.Event) { d.afterOpen(e) },
34.                         "after_event": func(_ context.Context, e *fsm.Event) { d.afterEvent(e) },
35.                 },
36.         )
38.         return d
39. }
41. func (d *Door) beforeOpen(e *fsm.Event) {
42.         fmt.Printf("beforeOpen, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
43. }
45. func (d *Door) beforeEvent(e *fsm.Event) {
46.         fmt.Printf("beforeEvent, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
47. }
49. func (d *Door) leaveClosed(e *fsm.Event) {
50.         fmt.Printf("leaveClosed, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
51. }
53. func (d *Door) leaveState(e *fsm.Event) {
54.         fmt.Printf("leaveState, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
55. }
58. func (d *Door) enterOpen(e *fsm.Event) {
59.         fmt.Printf("enterOpen, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
60. }
63. func (d *Door) enterState(e *fsm.Event) {
64.         fmt.Printf("enterState, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
65. }
68. func (d *Door) afterOpen(e *fsm.Event) {
69.         fmt.Printf("afterOpen, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
70. }
72. func (d *Door) afterEvent(e *fsm.Event) {
73.         fmt.Printf("afterEvent, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
74. }
78. func main() {
79.         door := NewDoor("测试")
81.         fmt.Printf("fsm current state: %s \n", door.FSM.Current())
83.         err := door.FSM.Event(context.Background(), "open")
84.         if err != nil {
85.                 fmt.Println(err)
86.         }
87.         fmt.Printf("fsm current state: %s \n", door.FSM.Current())
89.         err = door.FSM.Event(context.Background(), "close")
90.         if err != nil {
91.                 fmt.Println(err)
92.         }
93.         fmt.Printf("fsm current state: %s \n", door.FSM.Current())
94. }

复制代码

执行结果：大家重点看current state何时发生的变化。

1. fsm current state: closed
2. beforeOpen, current state:closed, Dst:open
3. beforeEvent, current state:closed, Dst:open
4. leaveClosed, current state:closed, Dst:open
5. leaveState, current state:closed, Dst:open
6. enterOpen, current state:open, Dst:open
7. enterState, current state:open, Dst:open
8. afterOpen, current state:open, Dst:open
9. afterEvent, current state:open, Dst:open
10. fsm current state: open
11. beforeEvent, current state:open, Dst:closed
12. leaveState, current state:open, Dst:closed
13. enterState, current state:closed, Dst:closed
14. afterEvent, current state:closed, Dst:closed
15. fsm current state: closed

复制代码

参考资料：
looplab/fsm 源码阅读
有限状态机FSM
深入浅出理解有限状态机
[有限状态机](

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！