什么是状态机？用C语言实现进程5状态模型

 前言

10年积累的成都网站设计、网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有陈仓免费网站建设让你可以放心的选择与我们合作。

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

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

本篇通过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. 
  
  
  
  
  2.   sta_origin=0, 
    3. 
  
  
  
  
  3.   sta_running, 
    4. 
  
  
  
  
  4.   sta_owencpu, 
    5. 
  
  
  
  
  5.   sta_sleep_int, 
    6. 
  
  
  
  
  6.   sta_sleep_unint 
    7. 
  
  
  
  
  7. }State; 
    8.

发生的事件如下：

 
 
 
 
    
  
  
  
  
  1. typedef enum{ 
    2. 
  
  
  
  
  2.   evt_fork=0, 
    3. 
  
  
  
  
  3.   evt_sched, 
    4. 
  
  
  
  
  4.   evt_wait, 
    5. 
  
  
  
  
  5.   evt_wait_unint, 
    6. 
  
  
  
  
  6.   evt_wake_up, 
    7. 
  
  
  
  
  7.   evt_wake,  
    8. 
  
  
  
  
  8. }EventID; 
    9.

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

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

 
 
 
 
    
  
  
  
  
  1. typedef struct { 
    2. 
  
  
  
  
  2.   State curState;//当前状态 
    3. 
  
  
  
  
  3.   EventID eventId;//事件ID 
    4. 
  
  
  
  
  4.   State nextState;//下个状态 
    5. 
  
  
  
  
  5.   CallBack action;//回调函数，事件发生后，调用对应的回调函数 
    6. 
  
  
  
  
  6. }StateTransform ;  
    7.

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

 
 
 
 
    
  
  
  
  
  1. void action_callback(void *arg) 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.  StateTransform *statTran = (StateTransform *)arg; 
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5.  if(statename[statTran->curState] == statename[statTran->nextState]) 
    6. 
  
  
  
  
  6.  { 
    7. 
  
  
  
  
  7.   printf("invalid event,state not change\n"); 
    8. 
  
  
  
  
  8.  }else{ 
    9. 
  
  
  
  
  9.   printf("call back state from %s --> %s\n", 
    10. 
  
  
  
  
  10.    statename[statTran->curState], 
    11. 
  
  
  
  
  11.    statename[statTran->nextState]); 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13. } 
    14.

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

 
 
 
 
    
  
  
  
  
  1. /*origin*/ 
    2. 
  
  
  
  
  2. StateTransform stateTran_0[]={ 
    3. 
  
  
  
  
  3.  {sta_origin,evt_fork,        sta_running,action_callback}, 
    4. 
  
  
  
  
  4.  {sta_origin,evt_sched,       sta_origin,NULL}, 
    5. 
  
  
  
  
  5.  {sta_origin,evt_wait,        sta_origin,NULL}, 
    6. 
  
  
  
  
  6.  {sta_origin,evt_wait_unint,  sta_origin,NULL}, 
    7. 
  
  
  
  
  7.  {sta_origin,evt_wake_up,     sta_origin,NULL}, 
    8. 
  
  
  
  
  8.  {sta_origin,evt_wake,        sta_origin,NULL}, 
    9. 
  
  
  
  
  9. };  
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. /*running*/ 
    12. 
  
  
  
  
  12. StateTransform stateTran_1[]={ 
    13. 
  
  
  
  
  13.  {sta_running,evt_fork,        sta_running,NULL}, 
    14. 
  
  
  
  
  14.  {sta_running,evt_sched,       sta_owencpu,action_callback}, 
    15. 
  
  
  
  
  15.  {sta_running,evt_wait,        sta_running,NULL}, 
    16. 
  
  
  
  
  16.  {sta_running,evt_wait_unint,  sta_running,NULL}, 
    17. 
  
  
  
  
  17.  {sta_running,evt_wake_up,     sta_running,NULL}, 
    18. 
  
  
  
  
  18.  {sta_running,evt_wake,        sta_running,NULL}, 
    19. 
  
  
  
  
  19. };  
    20. 
  
  
  
  
  20. /*owencpu*/ 
    21. 
  
  
  
  
  21. StateTransform stateTran_2[]={ 
    22. 
  
  
  
  
  22.  {sta_owencpu,evt_fork,        sta_owencpu,NULL}, 
    23. 
  
  
  
  
  23.  {sta_owencpu,evt_sched,       sta_owencpu,NULL}, 
    24. 
  
  
  
  
  24.  {sta_owencpu,evt_wait,        sta_sleep_int,action_callback}, 
    25. 
  
  
  
  
  25.  {sta_owencpu,evt_wait_unint,  sta_sleep_unint,action_callback}, 
    26. 
  
  
  
  
  26.  {sta_owencpu,evt_wake_up,     sta_owencpu,NULL}, 
    27. 
  
  
  
  
  27.  {sta_owencpu,evt_wake,        sta_owencpu,NULL}, 
    28. 
  
  
  
  
  28. };  
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. /*sleep_int*/ 
    31. 
  
  
  
  
  31. StateTransform stateTran_3[]={ 
    32. 
  
  
  
  
  32.  {sta_sleep_int,evt_fork,        sta_sleep_int,NULL}, 
    33. 
  
  
  
  
  33.  {sta_sleep_int,evt_sched,       sta_sleep_int,NULL}, 
    34. 
  
  
  
  
  34.  {sta_sleep_int,evt_wait,        sta_sleep_int,NULL}, 
    35. 
  
  
  
  
  35.  {sta_sleep_int,evt_wait_unint,  sta_sleep_int,NULL}, 
    36. 
  
  
  
  
  36.  {sta_sleep_int,evt_wake_up,     sta_sleep_int,NULL}, 
    37. 
  
  
  
  
  37.  {sta_sleep_int,evt_wake,        sta_running,action_callback}, 
    38. 
  
  
  
  
  38. };  
    39. 
  
  
  
  
  39. /*sleep_unint*/ 
    40. 
  
  
  
  
  40. StateTransform stateTran_4[]={ 
    41. 
  
  
  
  
  41.  {sta_sleep_unint,evt_fork,        sta_sleep_unint,NULL}, 
    42. 
  
  
  
  
  42.  {sta_sleep_unint,evt_sched,       sta_sleep_unint,NULL}, 
    43. 
  
  
  
  
  43.  {sta_sleep_unint,evt_wait,        sta_sleep_unint,NULL}, 
    44. 
  
  
  
  
  44.  {sta_sleep_unint,evt_wait_unint,  sta_sleep_unint,NULL}, 
    45. 
  
  
  
  
  45.  {sta_sleep_unint,evt_wake_up,     sta_running,action_callback}, 
    46. 
  
  
  
  
  46.  {sta_sleep_unint,evt_wake,        sta_sleep_unint,NULL}, 
    47. 
  
  
  
  
  47. };  
    48.

实现event发生函数：

 
 
 
 
    
  
  
  
  
  1. void event_happen(unsigned int event) 
    2. 
  
  
  
  
  2. 功能： 
    3. 
  
  
  
  
  3.  根据发生的event以及当前的进程state，找到对应的StateTransform 结构体，并调用do_action() 
    4. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. void do_action(StateTransform *statTran) 
    2. 
  
  
  
  
  2. 功能： 
    3. 
  
  
  
  
  3.  根据结构体变量StateTransform，实现状态迁移，并调用对应的回调函数。 
    4. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. #define STATETRANS(n)  (stateTran_##n) 
    2. 
  
  
  
  
  2. /*change state & call callback()*/ 
    3. 
  
  
  
  
  3. void do_action(StateTransform *statTran) 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5.  if(NULL == statTran) 
    6. 
  
  
  
  
  6.  { 
    7. 
  
  
  
  
  7.   perror("statTran is NULL\n"); 
    8. 
  
  
  
  
  8.   return; 
    9. 
  
  
  
  
  9.  } 
    10. 
  
  
  
  
  10.  //状态迁移 
    11. 
  
  
  
  
  11.  globalState = statTran->nextState; 
    12. 
  
  
  
  
  12.  if(statTran->action != NULL) 
    13. 
  
  
  
  
  13.  {//调用回调函数 
    14. 
  
  
  
  
  14.   statTran->action((void*)statTran); 
    15. 
  
  
  
  
  15.  }else{ 
    16. 
  
  
  
  
  16.   printf("invalid event,state not change\n"); 
    17. 
  
  
  
  
  17.  } 
    18. 
  
  
  
  
  18. } 
    19. 
  
  
  
  
  19. void event_happen(unsigned int event) 
    20. 
  
  
  
  
  20. { 
    21. 
  
  
  
  
  21.  switch(globalState) 
    22. 
  
  
  
  
  22.  { 
    23. 
  
  
  
  
  23.   case sta_origin: 
    24. 
  
  
  
  
  24.    do_action(&STATETRANS(0)[event]); 
    25. 
  
  
  
  
  25.    break; 
    26. 
  
  
  
  
  26.   case sta_running: 
    27. 
  
  
  
  
  27.    do_action(&STATETRANS(1)[event]); 
    28. 
  
  
  
  
  28.    break; 
    29. 
  
  
  
  
  29.   case sta_owencpu: 
    30. 
  
  
  
  
  30.    do_action(&STATETRANS(2)[event]);  
    31. 
  
  
  
  
  31.    break; 
    32. 
  
  
  
  
  32.   case sta_sleep_int: 
    33. 
  
  
  
  
  33.    do_action(&STATETRANS(3)[event]);  
    34. 
  
  
  
  
  34.    break; 
    35. 
  
  
  
  
  35.   case sta_sleep_unint: 
    36. 
  
  
  
  
  36.    do_action(&STATETRANS(4)[event]);  
    37. 
  
  
  
  
  37.    break; 
    38. 
  
  
  
  
  38.   default: 
    39. 
  
  
  
  
  39.    printf("state is invalid\n"); 
    40. 
  
  
  
  
  40.    break; 
    41. 
  
  
  
  
  41.  } 
    42. 
  
  
  
  
  42. } 
    43.

测试程序：功能：

  1. 初始化状态机的初始状态为sta_origin;
  2. 创建子线程，每隔一秒钟显示当前进程状态;
  3. 事件发生顺序为：evt_fork-->evt_sched-->evt_sched-->evt_wait-->evt_wake。

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

main.c

 
 
 
 
    
  
  
  
  
  1. /*显示当前状态*/ 
    2. 
  
  
  
  
  2. void *show_stat(void *arg) 
    3. 
  
  
  
  
  3. { 
    4. 
  
  
  
  
  4.  int len; 
    5. 
  
  
  
  
  5.  char buf[64]={0}; 
    6. 
  
  
  
  
  6.   
    7. 
  
  
  
  
  7.  while(1) 
    8. 
  
  
  
  
  8.  { 
    9. 
  
  
  
  
  9.   sleep(1); 
    10. 
  
  
  
  
  10.   printf("cur stat:%s\n",statename[globalState]); 
    11. 
  
  
  
  
  11.  }  
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13. void main(void) 
    14. 
  
  
  
  
  14. { 
    15. 
  
  
  
  
  15.  init_machine(); 
    16. 
  
  
  
  
  16.  //创建子线程，子线程主要用于显示当前状态 
    17. 
  
  
  
  
  17.  pthread_create(&pid, NULL,show_stat, NULL); 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19.  sleep(5); 
    20. 
  
  
  
  
  20.  event_happen(evt_fork); 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.  sleep(5); 
    23. 
  
  
  
  
  23.  event_happen(evt_sched); 
    24. 
  
  
  
  
  24.  sleep(5); 
    25. 
  
  
  
  
  25.  event_happen(evt_sched); 
    26. 
  
  
  
  
  26.  sleep(5); 
    27. 
  
  
  
  
  27.  event_happen(evt_wait); 
    28. 
  
  
  
  
  28.  sleep(5); 
    29. 
  
  
  
  
  29.  event_happen(evt_wake); 
    30. 
  
  
  
  
  30.   
    31. 
  
  
  
  
  31. } 
    32.

运行结果：

由结果可知：

 
 
 
 
    
  
  
  
  
  1. evt_fork-->evt_sched-->evt_sched-->evt_wait-->evt_wake 
    2.

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

 
 
 
 
    
  
  
  
  
  1. origen-->running-->owencpu-->owencpu-->sleep_int-->running 
    2.

本文转载自微信公众号「一口Linux」，可以通过以下二维码关注。转载本文请联系一口Linux公众号。

名称栏目：什么是状态机？用C语言实现进程5状态模型
URL分享：http://www.shufengxianlan.com/qtweb/news24/38624.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站改版知识

分类信息网站

眉山网站建设　　 　公司网站建设　　 　bgp机房托管　　 　广告媒介投放　　 　成都光华机房服务器托管　　 　自贡主机托管　　 　眉山托管服务器　　 　手机网站建设　　 　雕琢时光　　 　网站建设费用　　 　成都网站建设公司　　 　分类目录网站　　 　蜀锦在线　　 　电信机房托管　　 　装饰公司网站建设方案　　 　橡塑保温板　　 　和县翔豪网站　　 　成都商城app开发　　 　香港虚拟主机腾讯云　　 　香港云空间