Finite State Machine (FSM) bezieht sich auf ein mathematisches Modell, das aus einer begrenzten Anzahl von Zuständen und Verhaltensweisen wie Übergängen und Aktionen zwischen diesen Zuständen besteht. Es wird häufig im Computerbereich verwendet. FSM ist eine effiziente Programmiermethode, mit der die Verarbeitungslogik eines Programms innerhalb einer logischen Einheit implementiert wird. Insbesondere bei der Serverprogrammierung kann die Logik des Programms durch die Durchführung entsprechender Verarbeitungen basierend auf verschiedenen Zuständen oder Nachrichtentypen klarer und verständlicher gemacht werden . .
Wo werden Finite-State-Maschinen normalerweise verwendet?
Es kann auf Tokenizer (Tokenizer) angewendet werden, die Programmiersprachen oder natürliche Sprachen verarbeiten und die Grammatikanalyse und -analyse durch Bottom-up-Grammatikparser (Parser) in verschiedenen Kommunikationsprotokollen zwischen dem Sender und dem Empfänger implementieren Weitergabe von Daten, künstliche Intelligenz im Spiel und mehr.
Für die Implementierung endlicher Zustandsmaschinen gibt es im Allgemeinen die folgenden Methoden. Ich werde deren Vor- und Nachteile einzeln vorstellen.
Die Verwendung von if/else if-Anweisungen zur Implementierung endlicher Zustandsautomaten ist die einfachste und am leichtesten zu verstehende Methode. Verwenden Sie einfach eine große Anzahl von if/else if-Anweisungen, um den aktuellen Status zu ermitteln und die entsprechende logische Verarbeitung durchzuführen.
Das Folgende ist ein einfaches Beispiel für einen Zustandsautomaten. Wir verwenden eine große Anzahl von if/else if-Anweisungen, um ihn zu implementieren, entsprechende Operationen entsprechend verschiedenen Zuständen auszuführen und Zustandsübergänge zu implementieren.
enum
{
GET_UP,
GO_TO_SCHOOL,
HAVE_LUNCH,
GO_HOME,
DO_HOMEWORK,
SLEEP,
};
int
main()
{
int
state = GET_UP;
//小明的一天
while
(
1
)
{
if
(state == GET_UP)
{
GetUp
();
//具体调用的函数
state = GO_TO_SCHOOL;
//状态的转移
}
else
if
(state == GO_TO_SCHOOL)
{
Go2School
();
state = HAVE_LUNCH;
}
else
if
(state == HAVE_LUNCH)
{
HaveLunch
();
}
...
else
if
(state == SLEEP)
{
Go2Bed
();
state = GET_UP;
}
}
return
0
;
}
Was denken Sie, nachdem Sie die obigen Beispiele gelesen haben? Haben Sie das Gefühl, dass das Programm zwar einfach und leicht zu verstehen ist, aber eine große Anzahl von if-Beurteilungsanweisungen verwendet, was den Code sehr niedrig macht und den Code aufbläht? Dieser Zustandsautomat hat nur wenige Zustände und die Codeerweiterung ist nicht offensichtlich. Wenn wir jedoch Dutzende Zustände verarbeiten müssen, ist der Code dieses Zustandsautomaten schwer zu lesen.
Die Struktur des mithilfe von Switch-Anweisungen implementierten FSM ist klarer geworden, und auch seine Mängel sind offensichtlich: Obwohl diese Entwurfsmethode einfach ist und viele Beurteilungen erfordert, eignet sie sich für Zustandswechselprozesse im kleinen Maßstab, ist jedoch schwierig erweitern, wenn die Skala erweitert und gewartet wird.
int
state = GET_UP;
//小明的一天
while
(
1
)
{
switch
(state)
{
case
GET_UP:
GetUp
();
//具体调用的函数
state = GO_TO_SCHOOL;
//状态的转移
break
;
case
GO_TO_SCHOOL:
Go2School
();
state = HAVE_LUNCH;
break
;
case
HAVE_LUNCH:
HaveLunch
();
state = GO_HOME;
break
;
...
default
:
break
;
}
}
return
0
;
}
Die Idee, Funktionszeiger zum Implementieren von FSM zu verwenden: Erstellen Sie die entsprechende Statustabelle und Aktionsabfragetabelle, suchen Sie die entsprechende Aktionsverarbeitungsfunktion gemäß der Statustabelle, dem Ereignis und der Aktionstabelle und wechseln Sie dann den Status nach der Ausführung vollendet.
当然使用函数指针实现的 FSM 的过程还是比较费时费力，但是这一切都是值得的，因为当你的程序规模大时候，基于这种表结构的状态机，维护程序起来也是得心应手。
下面给出一个使用函数指针实现的 FSM 的框架：
我们还是以 “小明的一天” 为例设计出该 FSM。
先给出该 FSM 的状态转移图：
下面讲解关键部分代码实现
首先我们定义出小明一天的活动状态：
//比如我们定义了小明一天的状态如下
enum
{
GET_UP,
GO_TO_SCHOOL,
HAVE_LUNCH,
DO_HOMEWORK,
SLEEP,
};
我们也定义出会发生的事件
{
EVENT1 =
1
,
EVENT2,
EVENT3,
};
定义状态表的数据结构
typedef
struct
FsmTable_s
{
int
event
;
//事件
int
CurState
;
//当前状态
void
(*eventActFun)();
//函数指针
int
NextState
;
//下一个状态
}
FsmTable_t
;
接下来定义出最重要 FSM 的状态表，我们整个 FSM 就是根据这个定义好的表来运转的。
FsmTable_t
XiaoMingTable
[] =
{
//{到来的事件，当前的状态，将要要执行的函数，下一个状态}
{ EVENT1, SLEEP,
GetUp
, GET_UP },
{ EVENT2, GET_UP,
Go2School
, GO_TO_SCHOOL },
{ EVENT3, GO_TO_SCHOOL,
HaveLunch
, HAVE_LUNCH },
{ EVENT1, HAVE_LUNCH,
DoHomework
, DO_HOMEWORK },
{ EVENT2, DO_HOMEWORK,
Go2Bed
, SLEEP },
//add your codes here
};
状态机的注册、状态转移、事件处理的动作实现
/*状态机注册*/
void
FSM_Regist(
FSM_t
* pFsm,
FsmTable_t
* pTable)
{
pFsm->
FsmTable
= pTable;
}
/*状态迁移*/
void
FSM_StateTransfer(
FSM_t
* pFsm,
int
state)
{
pFsm->curState = state;
}
/*事件处理*/
void
FSM_EventHandle(
FSM_t
* pFsm,
int
event
)
{
FsmTable_t
* pActTable = pFsm->
FsmTable
;
void
(*eventActFun)() = NULL;
//函数指针初始化为空
int
NextState
;
int
CurState
= pFsm->curState;
int
flag =
0
;
//标识是否满足条件
int
i;
/*获取当前动作函数*/
for
(i =
0
; iif
(
event
== pActTable[i].
event
&&
CurState
== pActTable[i].
CurState
)
{
flag =
1
;
eventActFun = pActTable[i].eventActFun;
NextState
= pActTable[i].
NextState
;
break
;
}
}
if
(flag)
//如果满足条件了
{
/*动作执行*/
if
(eventActFun)
{
eventActFun();
}
//跳转到下一个状态
FSM_StateTransfer(pFsm,
NextState
);
}
else
{
// do nothing
}
}
主函数我们这样写，然后观察状态机的运转情况。
int
main()
{
FSM_t
fsm;
InitFsm
(&fsm);
int
event
= EVENT1;
//小明的一天,周而复始的一天又一天，进行着相同的活动
while
(
1
)
{
printf(
"event %d is coming...\n"
,
event
);
FSM_EventHandle(&fsm,
event
);
printf(
"fsm current state %d\n"
, fsm.curState);
test(&
event
);
sleep(
1
);
//休眠1秒，方便观察
}
return
0
;
}
看一看该状态机跑起来的状态转移情况：
上面的图可以看出，当且仅当在指定的状态下来了指定的事件才会发生函数的执行以及状态的转移，否则不会发生状态的跳转。这种机制使得这个状态机不停地自动运转，有条不絮地完成任务。
与前两种方法相比，使用函数指针实现 FSM 能很好用于大规模的切换流程，只要我们实现搭好了 FSM 框架，以后进行扩展就很简单了（只要在状态表里加一行来写入新的状态处理就可以了）。
Das obige ist der detaillierte Inhalt vonVerständnis und Implementierung von Finite State Machine FSM in der Linux-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
