21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 你是否也被蒙在鼓里？RTThread真正暂停线程的方法！ ...
返回列表 发新帖我要提问本帖赏金: 50.00元(功能说明)

[程序源码] 你是否也被蒙在鼓里？RTThread真正暂停线程的方法！

[复制链接]
 楼主| 二哲科技 发表于 2021-10-18 19:23 | 显示全部楼层 |阅读模式
<
线程, rtthread, ST, se, AC, ic
#申请原创# @21小跑堂 @21小跑堂 @21小跑堂
1.介绍
本以为暂停线程是一条语句的事，结果发现事情并没有那么简单，而且我相信很多人都用错了，就是因为踩了这么一个坑，所以准备发这么一个帖子，让后面的人少踩坑。
2.应用场景
有三个线程，分别为A、B和C，把A线程比作是大脑，B和C线程分别是扫地和洗碗，首先处于空闲状态，大脑让我去扫地，这时A线程中会开启B线程，第一次开启线程可以调用【rt_thread_startup】这个函数，没啥毛病，当老婆大人让我去洗碗，大脑瞬间做出反应去洗碗，这时A线程会关闭B线程然后打开C线程，那么A线程关闭B线程是调用【rt_thread_suspend】这个函数吗？看着没啥问题哦，但是里面存在很大的问题！这里先不说，继续往下走，当洗完碗还得继续扫地，让A线程恢复B线程需要调用【rt_thread_resume】这个函数。
上面这个应用场景就实现了，A线程暂停和恢复B线程，看着是没什么问题，我们先来实际操作一下，看看有什么问题！
3.场景再现
硬件：STM32F407VET6
RTThread版本：3.1.3Nano
首先按照上面的应用场景走一遍，设计三个线程，分别为A、B和C，然后开始运行，具体代码如下：
复制
  1. #include <rtthread.h>
    


  2. 

  3. ALIGN(RT_ALIGN_SIZE)
    

  4. static rt_uint8_t a_thread_stack[ 512 ];
    


  5. 

  6. ALIGN(RT_ALIGN_SIZE)
    

  7. static rt_uint8_t b_thread_stack[ 512 ];
    


  8. 

  9. ALIGN(RT_ALIGN_SIZE)
    

  10. static rt_uint8_t c_thread_stack[ 512 ];
    


  11. 

  12. static struct rt_thread a_thread;
    

  13. static struct rt_thread b_thread;
    

  14. static struct rt_thread c_thread;
    


  15. 

  16. static void a_thread_entry(void *parameter)
    

  17. {
    

  18.     unsigned int count = 0;
    


  19. 

  20.     while (1)
    

  21.     {
    

  22.         count++;
    

  23.         if(count == 10)
    

  24.         {
    

  25.             rt_kprintf("b start!\n");
    

  26.             rt_thread_startup(&b_thread);   //开始扫地
    

  27.         }
    

  28.         else if(count == 30)
    

  29.         {
    

  30.             rt_kprintf("b pause!\n");
    

  31.             rt_thread_suspend(&b_thread);   //停止扫地
    

  32.             rt_kprintf("c start!\n");
    

  33.             rt_thread_startup(&c_thread);   //开始洗碗
    

  34.         }
    

  35.         else if(count == 50)
    

  36.         {
    

  37.             rt_kprintf("c pause!\n");
    

  38.             rt_thread_suspend(&c_thread);   //停止洗碗
    

  39.             rt_kprintf("b start!\n");
    

  40.             rt_thread_resume(&b_thread);    //开始扫地
    

  41.         }
    

  42.         rt_thread_delay(100);
    

  43.     }
    

  44. }
    


  45. 

  46. static void b_thread_entry(void *parameter)
    

  47. {
    

  48.     unsigned int count = 0;
    


  49. 

  50.     while (1)
    

  51.     {
    

  52.         rt_kprintf("b thread run!\n");
    

  53.         rt_thread_delay(300);
    

  54.     }
    

  55. }
    


  56. 

  57. static void c_thread_entry(void *parameter)
    

  58. {
    

  59.     unsigned int count = 0;
    


  60. 

  61.     while (1)
    

  62.     {
    

  63.         rt_kprintf("c thread run!\n");
    

  64.         rt_thread_delay(100);
    

  65.     }
    

  66. }
    


  67. 

  68. int pause_thread_init(void)
    

  69. {
    

  70.     rt_err_t result;
    


  71. 

  72.     /* init led thread */
    

  73.     result = rt_thread_init(&a_thread,
    

  74.                             "a_thread",
    

  75.                             a_thread_entry,
    

  76.                             RT_NULL,
    

  77.                             (rt_uint8_t *)&a_thread_stack[0],
    

  78.                             sizeof(a_thread_stack),
    

  79.                             5,
    

  80.                             5);
    

  81.                             
    

  82.     if (result == RT_EOK)
    

  83.     {
    

  84.         rt_thread_startup(&a_thread);
    

  85.     }
    

  86.     
    

  87.     /* init led thread */
    

  88.     result = rt_thread_init(&b_thread,
    

  89.                             "b_thread",
    

  90.                             b_thread_entry,
    

  91.                             RT_NULL,
    

  92.                             (rt_uint8_t *)&b_thread_stack[0],
    

  93.                             sizeof(b_thread_stack),
    

  94.                             6,
    

  95.                             5);
    

  96.                             
    

  97.     
    

  98.     /* init led thread */
    

  99.     result = rt_thread_init(&c_thread,
    

  100.                             "c_thread",
    

  101.                             c_thread_entry,
    

  102.                             RT_NULL,
    

  103.                             (rt_uint8_t *)&c_thread_stack[0],
    

  104.                             sizeof(c_thread_stack),
    

  105.                             7,
    

  106.                             5);
    

  107.                             
    

  108.     return 0;
    

  109. }
    


  110. 

  111. /* 导出到 msh 命令列表中 */
    

  112. MSH_CMD_EXPORT(pause_thread_init, pause thread);


来看看实际的效果，如下图1所示，可以发现调用【rt_thread_suspend】函数并没有真正停止线程B或线程C。
图1
这是为什么呢？我们上RTThread官网看一下，观看图2可以发现【rt_thread_suspend】的函数说明中，特意的说明了这个函数不能通过A线程挂起B线程。
图2
同时我也上网查了一下，大家都有这个疑问，然后我们翻开源码看一下，在这个函数中有这么一个判断，会判断需要挂起线程的状态，如果线程不等于就绪态那么就不会进入挂起，而sleep，delay等函数都会导致线程的挂起，那么其他线程想要挂起这个线程肯定会掉到这个if里面，从而挂起不了这个线程。
图3
4.解决方案
可以使用删除线程和创建线程的方式来停止线程的运行，但是这个对线程有一定的要求，比如线程没有运行时长的变量，如果有的话，线程删除了这个变量的值也会被复位，要么这个变量设置为全局变量，但是这样就不太合适，代码实现如下所示：
复制
  1. #include <rtthread.h>
    


  2. 

  3. ALIGN(RT_ALIGN_SIZE)
    

  4. static rt_uint8_t a_thread_stack[ 512 ];
    


  5. 

  6. ALIGN(RT_ALIGN_SIZE)
    

  7. static rt_uint8_t b_thread_stack[ 512 ];
    


  8. 

  9. ALIGN(RT_ALIGN_SIZE)
    

  10. static rt_uint8_t c_thread_stack[ 512 ];
    


  11. 

  12. static struct rt_thread a_thread;
    

  13. static struct rt_thread b_thread;
    

  14. static struct rt_thread c_thread;
    


  15. 

  16. static void b_thread_entry(void *parameter);
    

  17. static void c_thread_entry(void *parameter);
    


  18. 

  19. static void a_thread_entry(void *parameter)
    

  20. {
    

  21.     unsigned int count = 0;
    


  22. 

  23.     while (1)
    

  24.     {
    

  25.         count++;
    

  26.         if(count == 10)
    

  27.         {
    

  28.             rt_kprintf("b start!\n");
    

  29.             /* init led thread */
    

  30.             rt_thread_init(&b_thread,
    

  31.                             "b_thread",
    

  32.                             b_thread_entry,
    

  33.                             RT_NULL,
    

  34.                             (rt_uint8_t *)&b_thread_stack[0],
    

  35.                             sizeof(b_thread_stack),
    

  36.                             6,
    

  37.                             5);
    

  38.             rt_thread_startup(&b_thread);   //开始扫地
    

  39.         }
    

  40.         else if(count == 30)
    

  41.         {
    

  42.             rt_kprintf("b pause!\n");
    

  43.             rt_thread_detach(&b_thread);    //停止扫地
    

  44.             rt_kprintf("c start!\n");
    

  45.             rt_thread_init(&c_thread,
    

  46.                             "c_thread",
    

  47.                             c_thread_entry,
    

  48.                             RT_NULL,
    

  49.                             (rt_uint8_t *)&c_thread_stack[0],
    

  50.                             sizeof(c_thread_stack),
    

  51.                             7,
    

  52.                             5);
    

  53.             rt_thread_startup(&c_thread);   //开始洗碗
    

  54.         }
    

  55.         else if(count == 50)
    

  56.         {
    

  57.             rt_kprintf("c pause!\n");
    

  58.             rt_thread_detach(&c_thread);    //停止洗碗
    

  59.             rt_kprintf("b start!\n");
    

  60.             rt_thread_init(&b_thread,
    

  61.                             "b_thread",
    

  62.                             b_thread_entry,
    

  63.                             RT_NULL,
    

  64.                             (rt_uint8_t *)&b_thread_stack[0],
    

  65.                             sizeof(b_thread_stack),
    

  66.                             6,
    

  67.                             5);
    

  68.             rt_thread_startup(&b_thread);   //开始扫地
    

  69.         }
    

  70.         rt_thread_delay(100);
    

  71.     }
    

  72. }
    


  73. 

  74. static void b_thread_entry(void *parameter)
    

  75. {
    

  76.     unsigned int count = 0;
    


  77. 

  78.     while (1)
    

  79.     {
    

  80.         rt_kprintf("b thread run!\n");
    

  81.         rt_thread_delay(300);
    

  82.     }
    

  83. }
    


  84. 

  85. static void c_thread_entry(void *parameter)
    

  86. {
    

  87.     unsigned int count = 0;
    


  88. 

  89.     while (1)
    

  90.     {
    

  91.         rt_kprintf("c thread run!\n");
    

  92.         rt_thread_delay(100);
    

  93.     }
    

  94. }
    


  95. 

  96. int pause_thread_init(void)
    

  97. {
    

  98.     rt_err_t result;
    


  99. 

  100.     /* init led thread */
    

  101.     result = rt_thread_init(&a_thread,
    

  102.                             "a_thread",
    

  103.                             a_thread_entry,
    

  104.                             RT_NULL,
    

  105.                             (rt_uint8_t *)&a_thread_stack[0],
    

  106.                             sizeof(a_thread_stack),
    

  107.                             5,
    

  108.                             5);
    

  109.                             
    

  110.     if (result == RT_EOK)
    

  111.     {
    

  112.         rt_thread_startup(&a_thread);
    

  113.     }
    

  114.                             
    

  115.     return 0;
    

  116. }
    


  117. 

  118. /* 导出到 msh 命令列表中 */
    

  119. MSH_CMD_EXPORT(pause_thread_init, pause thread);


查看下图2，可以看到这个方式可以实现线程停止的功能，但是这种方式非常有局限性，而且开销比较大，因为需要不停的初始化和脱离线程，并且对任务中的变量有一定的要求，非常容易让代码产生BUG，一般不采纳。
图4
这里我推荐使用信号量的方法来暂停线程，首先定义一个暂停信号量，然后在需要暂停的线程中去不停的监测这个信号量，当接收到信号量时，自己主动挂起线程并让出CPU，这样就可以实现暂停线程，而且还能够知道线程暂停在哪。代码实现如下：
复制
  1. #include <rtthread.h>
    


  2. 

  3. ALIGN(RT_ALIGN_SIZE)
    

  4. static rt_uint8_t a_thread_stack[ 512 ];
    


  5. 

  6. ALIGN(RT_ALIGN_SIZE)
    

  7. static rt_uint8_t b_thread_stack[ 512 ];
    


  8. 

  9. ALIGN(RT_ALIGN_SIZE)
    

  10. static rt_uint8_t c_thread_stack[ 512 ];
    


  11. 

  12. static struct rt_thread a_thread;
    

  13. static struct rt_thread b_thread;
    

  14. static struct rt_thread c_thread;
    


  15. 

  16. static rt_sem_t b_pause_sem = RT_NULL;
    

  17. static rt_sem_t c_pause_sem = RT_NULL;
    


  18. 

  19. static void a_thread_entry(void *parameter)
    

  20. {
    

  21.     unsigned int count = 0;
    


  22. 

  23.     while (1)
    

  24.     {
    

  25.         count++;
    

  26.         if(count == 10)
    

  27.         {
    

  28.             rt_kprintf("b start!\n");
    

  29.             rt_thread_startup(&b_thread);   //开始扫地
    

  30.         }
    

  31.         else if(count == 30)
    

  32.         {
    

  33.             rt_kprintf("b pause!\n");
    

  34.             rt_sem_release(b_pause_sem);//rt_thread_suspend(&b_thread);   //停止扫地
    

  35.             rt_kprintf("c start!\n");
    

  36.             rt_thread_startup(&c_thread);   //开始洗碗
    

  37.         }
    

  38.         else if(count == 50)
    

  39.         {
    

  40.             rt_kprintf("c pause!\n");
    

  41.             rt_sem_release(c_pause_sem);//rt_thread_suspend(&c_thread);   //停止洗碗
    

  42.             rt_kprintf("b start!\n");
    

  43.             rt_thread_resume(&b_thread);    //开始扫地
    

  44.         }
    

  45.         rt_thread_delay(100);
    

  46.     }
    

  47. }
    


  48. 

  49. static void b_thread_entry(void *parameter)
    

  50. {
    

  51.     unsigned int count = 0;
    


  52. 

  53.     while (1)
    

  54.     {
    

  55.         rt_kprintf("b thread run!\n");
    

  56.         rt_thread_delay(300);
    

  57.         if(rt_sem_take(b_pause_sem, 0) == RT_EOK)
    

  58.         {
    

  59.             rt_thread_suspend(&b_thread);   //停止扫地
    

  60.             rt_schedule();
    

  61.         }
    

  62.     }
    

  63. }
    


  64. 

  65. static void c_thread_entry(void *parameter)
    

  66. {
    

  67.     unsigned int count = 0;
    


  68. 

  69.     while (1)
    

  70.     {
    

  71.         rt_kprintf("c thread run!\n");
    

  72.         rt_thread_delay(100);
    

  73.         if(rt_sem_take(c_pause_sem, 0) == RT_EOK)
    

  74.         {
    

  75.             rt_thread_suspend(&c_thread);   //停止扫地
    

  76.             rt_schedule();
    

  77.         }
    

  78.     }
    

  79. }
    


  80. 

  81. int pause_thread_init(void)
    

  82. {
    

  83.     rt_err_t result;
    

  84.     
    

  85.     b_pause_sem = rt_sem_create("b_pause", 0, RT_IPC_FLAG_PRIO);
    

  86.     
    

  87.     c_pause_sem = rt_sem_create("c_pause", 0, RT_IPC_FLAG_PRIO);
    


  88. 

  89.     /* init led thread */
    

  90.     result = rt_thread_init(&a_thread,
    

  91.                             "a_thread",
    

  92.                             a_thread_entry,
    

  93.                             RT_NULL,
    

  94.                             (rt_uint8_t *)&a_thread_stack[0],
    

  95.                             sizeof(a_thread_stack),
    

  96.                             5,
    

  97.                             5);
    

  98.                             
    

  99.     if (result == RT_EOK)
    

  100.     {
    

  101.         rt_thread_startup(&a_thread);
    

  102.     }
    

  103.     
    

  104.     /* init led thread */
    

  105.     result = rt_thread_init(&b_thread,
    

  106.                             "b_thread",
    

  107.                             b_thread_entry,
    

  108.                             RT_NULL,
    

  109.                             (rt_uint8_t *)&b_thread_stack[0],
    

  110.                             sizeof(b_thread_stack),
    

  111.                             6,
    

  112.                             5);
    

  113.                             
    

  114.     
    

  115.     /* init led thread */
    

  116.     result = rt_thread_init(&c_thread,
    

  117.                             "c_thread",
    

  118.                             c_thread_entry,
    

  119.                             RT_NULL,
    

  120.                             (rt_uint8_t *)&c_thread_stack[0],
    

  121.                             sizeof(c_thread_stack),
    

  122.                             7,
    

  123.                             5);
    

  124.                             
    

  125.     return 0;
    

  126. }
    


  127. 

  128. /* 导出到 msh 命令列表中 */
    

  129. MSH_CMD_EXPORT(pause_thread_init, pause thread);
运行结果如图5所示，可以正常暂停，当然这个办法也有一些问题，挂起线程会有延时，只要这个延时不影响程序的整体运行，这个方法还是非常不错的！
图5
5.总结
希望RTThread能出一些更好暂停线程的方法，上述的方法只能作为应急使用，并不是最优的解决方案，A线程暂停B线程，这个场景是经常会使用到的，所以希望可以优化这个功能！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

打赏榜单

21小跑堂 打赏了 50.00 元 2021-10-20
理由：恭喜通过原创文章审核！请多多加油哦！

评分

参与人数 1威望 +10 收起 理由
MianQi + 10 赞一个!

查看全部评分

相关帖子
qin552011373 发表于 2021-10-29 09:48 | 显示全部楼层
多谢分享
回复 赏

举报

昊430 发表于 2021-11-2 10:32 | 显示全部楼层
学习了
回复 赏

举报

yanzhengxin1 发表于 2021-11-5 18:06 | 显示全部楼层
够深入，值得实践一下
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

二哲科技

16

主题

175

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部