状态机-用C语言实现进程5状态模型

前言

状态机在实际工作开发中应用非常广泛，在刚进入公司的时候，根据公司产品做流程图的时候，发现自己经常会漏了这样或那样的状态，导致整体流程会有问题，后来知道了状态机这样的东西，发现用这幅图就可以很清晰的表达整个状态的流转。

一口君曾经做过很多网络协议模块，很多协议的开发都必须用到状态机；一个健壮的状态机可以让你的程序，不论发生何种突发事件都不会突然进入一个不可预知的程序分支。

本篇通过C语言实现一个简单的进程5状态模型的状态机，让大家熟悉一下状态机的魅力。

什么是状态机？

定义

状态机是有限状态自动机的简称，是现实事物运行规则抽象而成的一个数学模型。

先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个LED等，就有 亮 和 灭两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如LED灯的状态就是两个 亮和 灭。

状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换图。

举例

以物理课学的灯泡图为例，就是一个最基本的小型状态机

可以画出以下的状态机图

这里就是两个状态：①灯泡亮，②灯泡灭 如果打开开关，那么状态就会切换为 灯泡亮 。灯泡亮 状态下如果关闭开关，状态就会切换为 灯泡灭。

状态机的全称是有限状态自动机，自动两个字也是包含重要含义的。给定一个状态机，同时给定它的当前状态以及输入，那么输出状态时可以明确的运算出来的。例如对于灯泡，给定初始状态灯泡灭 ，给定输入“打开开关”，那么下一个状态时可以运算出来的。

四大概念

下面来给出状态机的四大概念。

1. State ，状态。一个状态机至少要包含两个状态。例如上面灯泡的例子，有 灯泡亮和 灯泡灭两个状态。

2. Event ，事件。事件就是执行某个操作的触发条件或者口令。对于灯泡，“打开开关”就是一个事件。

3. Action ，动作。事件发生以后要执行动作。例如事件是“打开开关”，动作是“开灯”。编程的时候，一个 Action 一般就对应一个函数。

4. Transition ，变换。也就是从一个状态变化为另一个状态。例如“开灯过程”就是一个变换。

状态机的应用

状态机是一个对真实世界的抽象，而且是逻辑严谨的数学抽象，所以明显非常适合用在数字领域。可以应用到各个层面上，例如硬件设计，编译器设计，以及编程实现各种具体业务逻辑的时候。

进程5状态模型

进程管理是Linux五大子系统之一，非常重要，实际实现起来非常复杂，我们来看下进程是如何切换状态的。

下图是进程的5状态模型：

关于该图简单介绍如下：

1. 可运行态：当进程正在被CPU执行，或已经准备就绪随时可由调度程序执行，则称该进程为处于运行状态（running）。进程可以在内核态运行，也可以在用户态运行。当系统资源已经可用时，进程就被唤醒而进入准备运行状态，该状态称为就绪态。

2. 浅度睡眠态（可中断）：进程正在睡眠（被阻塞），等待资源到来是唤醒，也可以通过其他进程信号或时钟中断唤醒，进入运行队列。

3. 深度睡眠态(不可中断)：其和浅度睡眠基本类似，但有一点就是不可由其他进程信号或时钟中断唤醒。只有被使用wake_up()函数明确唤醒时才能转换到可运行的就绪状态。

4. 暂停状态：当进程收到信号SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU时就会进入暂停状态。可向其发送SIGCONT信号让进程转换到可运行状态。

5. 僵死状态：当进程已停止运行，但其父进程还没有询问其状态时，未释放PCB，则称该进程处于僵死状态。

进程的状态就是按照这个状态图进行切换的。

该状态流程有点复杂，因为我们目标只是实现一个简单的状态机，所以我们简化一下该状态机如下：

要想实现状态机，首先将该状态机转换成下面的状态迁移表。简要说明如下：假设当前进程处于running状态下，那么只有schedule事件发生之后，该进程才会产生状态的迁移，迁移到owencpu状态下，如果在此状态下发生了其他的事件，比如wake、wait_event都不会导致状态的迁移。

如上图所示：

1. 每一列表示一个状态，每一行对应一个事件。

2. 该表是实现状态机的最核心的一个图，请读者详细对比该表和状态迁移图的的关系。

3. 实际场景中，进程的切换会远比这个图复杂，好在众多大神都帮我们解决了这些复杂的问题，我们只需要站在巨人的肩膀上就可以了。

实现

根据状态迁移表，定义该状态机的状态如下：

1. typedef enum {

2.   sta_origin=0,

3.   sta_running,

4.   sta_owencpu,

5.   sta_sleep_int,

6.   sta_sleep_unint

7. }State;

发生的事件如下：

1. typedef enum{

2.   evt_fork=0,

3.   evt_sched,

4.   evt_wait,

5.   evt_wait_unint,

6.   evt_wake_up,

7.   evt_wake, 

8. }EventID;

不论是状态还是事件都可以根据实际情况增加调整。

定义一个结构体用来表示当前状态转换信息：

1. typedef struct {

2.   State curState;//当前状态

3.   EventID eventId;//事件ID

4.   State nextState;//下个状态

5.   CallBack action;//回调函数，事件发生后，调用对应的回调函数

6. }StateTransform ; 

事件回调函数：实际应用中不同的事件发生需要执行不同的action，就需要定义不同的函数， 为方便起见，本例所有的事件都统一使用同一个回调函数。功能：打印事件发生后进程的前后状态，如果状态发生了变化，就调用对应的回调函数。

1. void action_callback(void *arg)

2. {

3.  StateTransform *statTran = (StateTransform *)arg;

4.  

5.  if(statename[statTran->curState] == statename[statTran->nextState])

6.  {

7.   printf("invalid event,state not change\n");

8.  }else{

9.   printf("call back state from %s --> %s\n",

10.    statename[statTran->curState],

11.    statename[statTran->nextState]);

12.  }

13. }

为各个状态定义迁移表数组：

1. /*origin*/

2. StateTransform stateTran_0[]={

3.  {sta_origin,evt_fork,        sta_running,action_callback},

4.  {sta_origin,evt_sched,       sta_origin,NULL},

5.  {sta_origin,evt_wait,        sta_origin,NULL},

6.  {sta_origin,evt_wait_unint,  sta_origin,NULL},

7.  {sta_origin,evt_wake_up,     sta_origin,NULL},

8.  {sta_origin,evt_wake,        sta_origin,NULL},

9. }; 

11. /*running*/

12. StateTransform stateTran_1[]={

13.  {sta_running,evt_fork,        sta_running,NULL},

14.  {sta_running,evt_sched,       sta_owencpu,action_callback},

15.  {sta_running,evt_wait,        sta_running,NULL},

16.  {sta_running,evt_wait_unint,  sta_running,NULL},

17.  {sta_running,evt_wake_up,     sta_running,NULL},

18.  {sta_running,evt_wake,        sta_running,NULL},

19. }; 

20. /*owencpu*/

21. StateTransform stateTran_2[]={

22.  {sta_owencpu,evt_fork,        sta_owencpu,NULL},

23.  {sta_owencpu,evt_sched,       sta_owencpu,NULL},

24.  {sta_owencpu,evt_wait,        sta_sleep_int,action_callback},

25.  {sta_owencpu,evt_wait_unint,  sta_sleep_unint,action_callback},

26.  {sta_owencpu,evt_wake_up,     sta_owencpu,NULL},

27.  {sta_owencpu,evt_wake,        sta_owencpu,NULL},

28. }; 

30. /*sleep_int*/

31. StateTransform stateTran_3[]={

32.  {sta_sleep_int,evt_fork,        sta_sleep_int,NULL},

33.  {sta_sleep_int,evt_sched,       sta_sleep_int,NULL},

34.  {sta_sleep_int,evt_wait,        sta_sleep_int,NULL},

35.  {sta_sleep_int,evt_wait_unint,  sta_sleep_int,NULL},

36.  {sta_sleep_int,evt_wake_up,     sta_sleep_int,NULL},

37.  {sta_sleep_int,evt_wake,        sta_running,action_callback},

38. }; 

39. /*sleep_unint*/

40. StateTransform stateTran_4[]={

41.  {sta_sleep_unint,evt_fork,        sta_sleep_unint,NULL},

42.  {sta_sleep_unint,evt_sched,       sta_sleep_unint,NULL},

43.  {sta_sleep_unint,evt_wait,        sta_sleep_unint,NULL},

44.  {sta_sleep_unint,evt_wait_unint,  sta_sleep_unint,NULL},

45.  {sta_sleep_unint,evt_wake_up,     sta_running,action_callback},

46.  {sta_sleep_unint,evt_wake,        sta_sleep_unint,NULL},

47. }; 

实现event发生函数：

1. void event_happen(unsigned int event)

2. 功能：

3.  根据发生的event以及当前的进程state，找到对应的StateTransform 结构体，并调用do_action()

1. void do_action(StateTransform *statTran)

2. 功能：

3.  根据结构体变量StateTransform，实现状态迁移，并调用对应的回调函数。

1. #define STATETRANS(n)  (stateTran_##n)

2. /*change state & call callback()*/

3. void do_action(StateTransform *statTran)

4. {

5.  if(NULL == statTran)

6.  {

7.   perror("statTran is NULL\n");

8.   return;

9.  }

10.  //状态迁移

11.  globalState = statTran->nextState;

12.  if(statTran->action != NULL)

13.  {//调用回调函数

14.   statTran->action((void*)statTran);

15.  }else{

16.   printf("invalid event,state not change\n");

17.  }

18. }

19. void event_happen(unsigned int event)

20. {

21.  switch(globalState)

22.  {

23.   case sta_origin:

24.    do_action(&STATETRANS(0)[event]);

25.    break;

26.   case sta_running:

27.    do_action(&STATETRANS(1)[event]);

28.    break;

29.   case sta_owencpu:

30.    do_action(&STATETRANS(2)[event]); 

31.    break;

32.   case sta_sleep_int:

33.    do_action(&STATETRANS(3)[event]); 

34.    break;

35.   case sta_sleep_unint:

36.    do_action(&STATETRANS(4)[event]); 

37.    break;

38.   default:

39.    printf("state is invalid\n");

40.    break;

41.  }

42. }

测试程序：功能：

1. 初始化状态机的初始状态为sta_origin；

2. 创建子线程，每隔一秒钟显示当前进程状态；

3. 事件发生顺序为：evt_fork-->evt_sched-->evt_sched-->evt_wait-->evt_wake。

读者可以跟自己的需要，修改事件发生顺序，观察状态的变化。

main.c

1. /*显示当前状态*/

2. void *show_stat(void *arg)

3. {

4.  int len;

5.  char buf[64]={0};

6.  

7.  while(1)

8.  {

9.   sleep(1);

10.   printf("cur stat:%s\n",statename[globalState]);

11.  } 

12. }

13. void main(void)

14. {

15.  init_machine();

16.  //创建子线程，子线程主要用于显示当前状态

17.  pthread_create(&pid, NULL,show_stat, NULL);

19.  sleep(5);

20.  event_happen(evt_fork);

22.  sleep(5);

23.  event_happen(evt_sched);

24.  sleep(5);

25.  event_happen(evt_sched);

26.  sleep(5);

27.  event_happen(evt_wait);

28.  sleep(5);

29.  event_happen(evt_wake);

30.  

31. }

运行结果：由结果可知：

evt_fork-->evt_sched-->evt_sched-->evt_wait-->evt_wake

该事件发生序列对应的状态迁移顺序为：

origen-->running-->owencpu-->owencpu-->sleep_int-->running

附件源代码：

#include <pthread.h>
#include <stdio.h>
#include <Windows.h>
#pragma comment(lib, "pthreadVC2.lib")

//定义对象所有的状态
typedef enum {
    sta_origin = 0,
    sta_running,
    sta_owencpu,
    sta_sleep_int,
    sta_sleep_unint
}State;

//定义对象的事件
typedef enum {
    evt_fork = 0,
    evt_sched,
    evt_wait,
    evt_wait_unint,
    evt_wake_up,
    evt_wake,
}EventID;

typedef void(*CallBack)(void *);

//定义对象的状态机
typedef struct {
    State curState;//当前状态
    EventID eventId;//事件ID
    State nextState;//下个状态
    CallBack action;//回调函数，事件发生后，调用对应的回调函数
}StateTransform;

//用于打印状态
static const char *statename[] = {
    "origin",
    "running",
    "owencpu",
    "sleep_int",
    "sleep_unint",

};

pthread_t pid;

//动作回调函数

void action_callback(void *arg)
{
    StateTransform *statTran = (StateTransform *)arg;

    if (statename[statTran->curState] == statename[statTran->nextState])
    {
        printf("invalid event,state not change\n");
    }
    else {
        printf("call back state from %s --> %s\n",
            statename[statTran->curState],
            statename[statTran->nextState]);
    }
}

//以状态为标准，建立状态机二维数组，当每次发生事件后下次的状态，以及执行的动作
/*origin*/
StateTransform stateTran_0[] = {
 {sta_origin,evt_fork,        sta_running,action_callback},
 {sta_origin,evt_sched,       sta_origin,NULL},
 {sta_origin,evt_wait,        sta_origin,NULL},
 {sta_origin,evt_wait_unint,  sta_origin,NULL},
 {sta_origin,evt_wake_up,     sta_origin,NULL},
 {sta_origin,evt_wake,        sta_origin,NULL},
};

/*running*/
StateTransform stateTran_1[] = {
 {sta_running,evt_fork,        sta_running,NULL},
 {sta_running,evt_sched,       sta_owencpu,action_callback},
 {sta_running,evt_wait,        sta_running,NULL},
 {sta_running,evt_wait_unint,  sta_running,NULL},
 {sta_running,evt_wake_up,     sta_running,NULL},
 {sta_running,evt_wake,        sta_running,NULL},
};
/*owencpu*/
StateTransform stateTran_2[] = {
 {sta_owencpu,evt_fork,        sta_owencpu,NULL},
 {sta_owencpu,evt_sched,       sta_owencpu,NULL},
 {sta_owencpu,evt_wait,        sta_sleep_int,action_callback},
 {sta_owencpu,evt_wait_unint,  sta_sleep_unint,action_callback},
 {sta_owencpu,evt_wake_up,     sta_owencpu,NULL},
 {sta_owencpu,evt_wake,        sta_owencpu,NULL},
};

/*sleep_int*/
StateTransform stateTran_3[] = {
 {sta_sleep_int,evt_fork,        sta_sleep_int,NULL},
 {sta_sleep_int,evt_sched,       sta_sleep_int,NULL},
 {sta_sleep_int,evt_wait,        sta_sleep_int,NULL},
 {sta_sleep_int,evt_wait_unint,  sta_sleep_int,NULL},
 {sta_sleep_int,evt_wake_up,     sta_sleep_int,NULL},
 {sta_sleep_int,evt_wake,        sta_running,action_callback},
};
/*sleep_unint*/
StateTransform stateTran_4[] = {
 {sta_sleep_unint,evt_fork,        sta_sleep_unint,NULL},
 {sta_sleep_unint,evt_sched,       sta_sleep_unint,NULL},
 {sta_sleep_unint,evt_wait,        sta_sleep_unint,NULL},
 {sta_sleep_unint,evt_wait_unint,  sta_sleep_unint,NULL},
 {sta_sleep_unint,evt_wake_up,     sta_running,action_callback},
 {sta_sleep_unint,evt_wake,        sta_sleep_unint,NULL},
};

void event_happen(unsigned int event);

/*
功能：
根据发生的event以及当前的进程state，找到对应的StateTransform 结构体，并调用do_action()
*/
void do_action(StateTransform *statTran);

/*
功能：
根据结构体变量StateTransform，实现状态迁移，并调用对应的回调函数。
*/
\

State globalState = sta_origin;

#define STATETRANS(n)  (stateTran_##n)        //连接符

//实现状态改变，执行回调动作
void do_action(StateTransform *statTran)
{
    if (NULL == statTran)
    {
        perror("statTran is NULL\n");
        return;
    }
    //状态迁移
    globalState = statTran->nextState;
    if (statTran->action != NULL)
    {//调用回调函数
        statTran->action((void*)statTran);
    }
    else {
        printf("invalid event,state not change\n");
    }
}

//对应状态迁移表，globalState 全局代表状态，event代表该状态下的事件
void event_happen(unsigned int event)
{
    switch (globalState)
    {
    case sta_origin:
        do_action(&STATETRANS(0)[event]);
        break;
    case sta_running:
        do_action(&STATETRANS(1)[event]);
        break;
    case sta_owencpu:
        do_action(&STATETRANS(2)[event]);
        break;
    case sta_sleep_int:
        do_action(&STATETRANS(3)[event]);
        break;
    case sta_sleep_unint:
        do_action(&STATETRANS(4)[event]);
        break;
    default:
        printf("state is invalid\n");
        break;
    }
}

/*显示当前状态*/
void *show_stat(void *arg)
{

    while (1)
    {
        Sleep(1);
        printf("cur stat:%s\n", statename[globalState]);
    }
}

void init_machine(void)
{
    globalState = sta_origin;
}

void main(void)
{
    init_machine();
    //创建子线程，子线程主要用于显示当前状态
    pthread_create(&pid, NULL, show_stat, NULL);

    Sleep(5);
    event_happen(evt_fork);

    Sleep(5);
    event_happen(evt_sched);
    Sleep(5);
    event_happen(evt_sched);
    Sleep(5);
    event_happen(evt_wait);
    Sleep(5);
    event_happen(evt_wake);

}