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>
  3. ALIGN(RT_ALIGN_SIZE)
  4. static rt_uint8_t a_thread_stack[ 512 ];
  6. ALIGN(RT_ALIGN_SIZE)
  7. static rt_uint8_t b_thread_stack[ 512 ];
  9. ALIGN(RT_ALIGN_SIZE)
  10. static rt_uint8_t c_thread_stack[ 512 ];
  12. static struct rt_thread a_thread;
  13. static struct rt_thread b_thread;
  14. static struct rt_thread c_thread;
  16. static void a_thread_entry(void *parameter)
  17. {
  18.     unsigned int count = 0;
  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. }
  46. static void b_thread_entry(void *parameter)
  47. {
  48.     unsigned int count = 0;
  50.     while (1)
  51.     {
  52.         rt_kprintf("b thread run!\n");
  53.         rt_thread_delay(300);
  54.     }
  55. }
  57. static void c_thread_entry(void *parameter)
  58. {
  59.     unsigned int count = 0;
  61.     while (1)
  62.     {
  63.         rt_kprintf("c thread run!\n");
  64.         rt_thread_delay(100);
  65.     }
  66. }
  68. int pause_thread_init(void)
  69. {
  70.     rt_err_t result;
  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. }
  111. /* 导出到 msh 命令列表中 */
  112. MSH_CMD_EXPORT(pause_thread_init, pause thread);
来看看实际的效果，如下图1所示，可以发现调用【rt_thread_suspend】函数并没有真正停止线程B或线程C。
1.png

图1

这是为什么呢？我们上RTThread官网看一下，观看图2可以发现【rt_thread_suspend】的函数说明中，特意的说明了这个函数不能通过A线程挂起B线程。
2.png

图2

同时我也上网查了一下，大家都有这个疑问，然后我们翻开源码看一下，在这个函数中有这么一个判断，会判断需要挂起线程的状态，如果线程不等于就绪态那么就不会进入挂起，而sleep，delay等函数都会导致线程的挂起，那么其他线程想要挂起这个线程肯定会掉到这个if里面，从而挂起不了这个线程。
3.png

图3

4.解决方案
可以使用删除线程和创建线程的方式来停止线程的运行，但是这个对线程有一定的要求，比如线程没有运行时长的变量，如果有的话，线程删除了这个变量的值也会被复位，要么这个变量设置为全局变量，但是这样就不太合适，代码实现如下所示：
  1. #include <rtthread.h>
  3. ALIGN(RT_ALIGN_SIZE)
  4. static rt_uint8_t a_thread_stack[ 512 ];
  6. ALIGN(RT_ALIGN_SIZE)
  7. static rt_uint8_t b_thread_stack[ 512 ];
  9. ALIGN(RT_ALIGN_SIZE)
  10. static rt_uint8_t c_thread_stack[ 512 ];
  12. static struct rt_thread a_thread;
  13. static struct rt_thread b_thread;
  14. static struct rt_thread c_thread;
  16. static void b_thread_entry(void *parameter);
  17. static void c_thread_entry(void *parameter);
  19. static void a_thread_entry(void *parameter)
  20. {
  21.     unsigned int count = 0;
  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. }
  74. static void b_thread_entry(void *parameter)
  75. {
  76.     unsigned int count = 0;
  78.     while (1)
  79.     {
  80.         rt_kprintf("b thread run!\n");
  81.         rt_thread_delay(300);
  82.     }
  83. }
  85. static void c_thread_entry(void *parameter)
  86. {
  87.     unsigned int count = 0;
  89.     while (1)
  90.     {
  91.         rt_kprintf("c thread run!\n");
  92.         rt_thread_delay(100);
  93.     }
  94. }
  96. int pause_thread_init(void)
  97. {
  98.     rt_err_t result;
  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. }
  118. /* 导出到 msh 命令列表中 */
  119. MSH_CMD_EXPORT(pause_thread_init, pause thread);
查看下图2，可以看到这个方式可以实现线程停止的功能，但是这种方式非常有局限性，而且开销比较大，因为需要不停的初始化和脱离线程，并且对任务中的变量有一定的要求，非常容易让代码产生BUG，一般不采纳。
4.png

图4

这里我推荐使用信号量的方法来暂停线程，首先定义一个暂停信号量，然后在需要暂停的线程中去不停的监测这个信号量，当接收到信号量时，自己主动挂起线程并让出CPU，这样就可以实现暂停线程，而且还能够知道线程暂停在哪。代码实现如下：
  1. #include <rtthread.h>
  3. ALIGN(RT_ALIGN_SIZE)
  4. static rt_uint8_t a_thread_stack[ 512 ];
  6. ALIGN(RT_ALIGN_SIZE)
  7. static rt_uint8_t b_thread_stack[ 512 ];
  9. ALIGN(RT_ALIGN_SIZE)
  10. static rt_uint8_t c_thread_stack[ 512 ];
  12. static struct rt_thread a_thread;
  13. static struct rt_thread b_thread;
  14. static struct rt_thread c_thread;
  16. static rt_sem_t b_pause_sem = RT_NULL;
  17. static rt_sem_t c_pause_sem = RT_NULL;
  19. static void a_thread_entry(void *parameter)
  20. {
  21.     unsigned int count = 0;
  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. }
  49. static void b_thread_entry(void *parameter)
  50. {
  51.     unsigned int count = 0;
  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. }
  65. static void c_thread_entry(void *parameter)
  66. {
  67.     unsigned int count = 0;
  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. }
  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);
  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. }
  128. /* 导出到 msh 命令列表中 */
  129. MSH_CMD_EXPORT(pause_thread_init, pause thread);
运行结果如图5所示，可以正常暂停，当然这个办法也有一些问题，挂起线程会有延时，只要这个延时不影响程序的整体运行，这个方法还是非常不错的！
5.png

图5

5.总结
希望RTThread能出一些更好暂停线程的方法，上述的方法只能作为应急使用，并不是最优的解决方案，A线程暂停B线程，这个场景是经常会使用到的，所以希望可以优化这个功能！