MCU智学网»网站论坛 › 嵌入式操作系统论坛 › RT-Thread › 帖子
发新帖

RT-Thread学习笔记——互斥量

[复制链接]
2263 0

本文包含源代码、原理图、PCB、封装库、中英文PDF等资源

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

x
前言
前面学习了RT-Thread的信号量，但信号量在一些场合使用会存在优先级翻转问题，接下来我们学习互斥量，在 RT-Thread 操作系统中，互斥量可以解决优先级翻转问题，实现的是优先级继承算法。互斥量和信号量不同的是：拥有互斥量的线程拥有互斥量的所有权，互斥量支持递归访问且能防止线程优先级翻转；并且互斥量只能由持有线程释放，而信号量则可以由任何线程释放。这里主要讲RT-Thread互斥量的工作机制、相关函数，在后面使用潘多拉开发板进行实验（STM32L475VET6）。

一、互斥量工作机制
1、在 RT-Thread 操作系统中，互斥量可以解决优先级翻转问题，实现的是优先级继承算法。优先级继承是通过在线程 A 尝试获取共享资源而被挂起的期间内，将线程 C 的优先级提升到线程 A 的优先级别，从而解决优先级翻转引起的问题。这样能够防止 C（间接地防止 A）被 B 抢占，如下图所示。优先级继承是指，提高某个占有某种资源的低优先级线程的优先级，使之与所有等待该资源的线程中优先级最高的那个线程的优先级相等，然后执行，而当这个低优先级线程释放该资源时，优先级重新回到初始设定。因此，继承优先级的线程避免了系统资源被任何中间优先级的线程抢占。

20190129135029901.png
优先级继承 (M 为互斥量 )——来源RT-Thread编程指南

二、互斥量的相关函数
1、创建动态互斥量函数

创建一个互斥量时，内核首先创建一个互斥量控制块，然后完成对该控制块的初始化工作。
  1. rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);

复制代码
（1）入口参数：

name：互斥量的名称。
flag：互斥量标志，它可以取如下数值：RT_IPC_FLAG_FIFO 或RT_IPC_FLAG_PRIO。为 RT_IPC_FLAG_PRIO时，表示在多个线程等待资源时，将由优先级高的线程优先获得资源。为 RT_IPC_FLAG_FIFO时，表示在多个线程等待资源时，将按照先来先得的顺序获得资源。

（2）返回值：

互斥量句柄：创建成功。
RT_NULL：创建失败。

2、删除动态互斥量函数

当不再使用动态互斥量时，通过删除动态互斥量以释放系统资源。当删除一个动态互斥量时，所有等待此互斥量的线程都将被唤醒，等待线程获得的返回值是 RT_ERROR，然后系统将该互斥量从内核对象管理器链表中删除并释放互斥量占用的内存空间。
  1. rt_err_t rt_mutex_delete(rt_mutex_t mutex);

复制代码
（1）入口参数：

mutex：要删除的动态互斥量对象的句柄。

（2）返回值：

RT_EOK：删除成功。

3、创建静态互斥量函数

这里所说的创建静态互斥量也就是《RT-Thread编程指南》里面的初始化互斥量，静态互斥量对象的内存是在系统编译时由编译器分配的，一般放于读写数据段或未初始化数据段中。
  1. rt_err_t rt_mutex_init (rt_mutex_t mutex, const char* name, rt_uint8_t flag);

复制代码
（1）入口参数：

mutex：互斥量对象的句柄，它由用户提供，并指向互斥量对象的内存块。
name：互斥量的名称。
flag：互斥量标志，它可以取如下数值：RT_IPC_FLAG_FIFO 或 RT_IPC_FLAG_PRIO。

（2）
RT_EOK：创建成功。

4、删除静态互斥量函数

这里所说的删除静态互斥量也就是《RT-Thread编程指南》里面所讲的脱离互斥量，脱离互斥量将把互斥量对象从内核对象管理器中脱离。使用该函数接口后，内核先唤醒所有挂在该互斥量上的线程（线程的返回值是RT_ERROR），然后系统将该互斥量从内核对象管理器中脱离。
  1. rt_err_t rt_mutex_detach (rt_mutex_t mutex);

复制代码
（1）入口参数：

mutex：要删除的静态互斥量对象的句柄。

（2）返回值：

RT_EOK：删除成功。

5、获取互斥量函数

线程获取了互斥量，那么线程就有了对该互斥量的所有权，即某一个时刻一个互斥量只能被一个线程持有。如果互斥量没有被其他线程控制，那么申请该互斥量的线程将成功获得该互斥量。如果互斥量已经被当前线程线程控制，则该互斥量的持有计数加 1，当前线程也不会挂起等待。如果互斥量已经被其他线程占有，则当前线程在该互斥量上挂起等待，直到其他线程释放它或者等待时间超过指定的超时时间。
  1. rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time);

复制代码
（1）入口参数：

mutex：互斥量对象的句柄。
time：指定等待的时间。

（2）返回值：

RT_EOK：成功获得互斥量。
RT_ETIMEOUT：超时。
RT_ERROR：获取失败。

6、释放互斥量函数

当线程完成互斥资源的访问后，应尽快释放它占据的互斥量，使得其他线程能及时获取该互斥量。使用该函数接口时，只有已经拥有互斥量控制权的线程才能释放它，每释放一次该互斥量，它的持有计数就减 1。当该互斥量的持有计数为零时（即持有线程已经释放所有的持有操作），它变为可用，等待在该信号量上的线程将被唤醒。如果线程的运行优先级被互斥量提升，那么当互斥量被释放后，线程恢复为持有互斥量前的优先级。
  1. rt_err_t rt_mutex_release(rt_mutex_t mutex);

复制代码
（1）入口参数：

mutex：互斥量对象的句柄。

（2）返回值：

RT_EOK ：成功。


三、基于STM32的互斥量示例
前面说了很多互斥量的理论知识，光说不练都是假把式，那么接下来我们就进行实际的操作。以下将列举两个示例，一个来演示互斥锁功能，另外一个演示防止优先级翻转特性，采用RTT&正点原子联合出品的潘多拉开发板进行实验。

1、互斥锁示例

在演示互斥锁功能，将定义一个全局变量用作公共资源，创建一个互斥量和两个线程，其中一个线程用于改变全局变量的值，另一个线程用于打印出改变后的全局变量值，互斥量用于防止变量值还没改变就被打印了。

（1）实现代码
  1. /* 线程句柄 */

  2. static rt_thread_t change_value_thread = RT_NULL;

  3. static rt_thread_t show_value_thread = RT_NULL;

  4.  

  5. /* 互斥量句柄 */

  6. static rt_mutex_t mutex = RT_NULL;

  7.  

  8. /* 全局表里，公共资源 */

  9. char g_value = 'A';

  10.  

  11. /**************************************************************

  12. 函数名称 : change_value_thread_entry

  13. 函数功能 : 修改公共资源线程入口函数

  14. 输入参数 : parameter：入口参数

  15. 返回值           : 无

  16. 备注                 : 无

  17. **************************************************************/

  18. void change_value_thread_entry(void *parameter)

  19. {

  20.         while(1) 

  21.         {

  22.                 rt_mutex_take(mutex, RT_WAITING_FOREVER);/* 获取互斥量，一直等直到获取到 */

  23.  

  24.                 if(g_value < 'Z')

  25.                 {

  26.                         g_value++;

  27.                 }

  28.                 else

  29.                 {

  30.                         g_value = 'A';

  31.                 }

  32.  

  33.                 rt_mutex_release(mutex); /* 释放互斥量 */

  34.                 

  35.                 rt_thread_mdelay(1);

  36.                 rt_thread_yield(); /* 放弃剩余时间片，进行一次线程切换 */

  37.         }

  38. }

  39.  

  40. /**************************************************************

  41. 函数名称 : show_value_thread_entry

  42. 函数功能 : 打印g_value

  43. 输入参数 : parameter：入口参数

  44. 返回值           : 无

  45. 备注                 : 无

  46. **************************************************************/

  47. void show_value_thread_entry(void *parameter)

  48. {

  49.         while(1) 

  50.         {

  51.                 rt_mutex_take(mutex, RT_WAITING_FOREVER);/* 获取互斥量，一直等直到获取到 */

  52.  

  53.                 rt_kprintf("g_value:%c\r\n", g_value);

  54.                 LED_R(0);

  55.                 rt_thread_mdelay(2000);

  56.                 LED_R(1);

  57.                 rt_thread_mdelay(2000);

  58.                 

  59.                 rt_mutex_release(mutex); /* 释放互斥量 */

  60.         }

  61. }

  62.  

  63.  

  64. void rtthread_mutex_test(void)

  65. {

  66.         /* 创建一个互斥量,先进先出模式*/

  67.         mutex = rt_mutex_create("mutex_test", RT_IPC_FLAG_PRIO);

  68.  

  69.         if(RT_NULL != mutex)

  70.         {

  71.                 rt_kprintf("create mutex successful\r\n");

  72.         }

  73.         else

  74.         {

  75.                 rt_kprintf("create mutex failed\r\n");

  76.                 return;

  77.         }

  78.         

  79.         /* 创建打印显示公共资源g_value线程 */

  80.         show_value_thread = rt_thread_create("show_value_thread",

  81.                                                 show_value_thread_entry,

  82.                                                 RT_NULL,

  83.                                                 512,

  84.                                                 3,

  85.                                                 20

  86.                                                 );

  87.         if(RT_NULL != show_value_thread)/* 创建成功，启动线程 */

  88.         {

  89.                 rt_thread_startup(show_value_thread);;

  90.         }

  91.         else

  92.         {

  93.                 rt_kprintf("create show_value_thread failed\r\n");

  94.                 return;

  95.         }

  96.  

  97.         /* 创建改变公共资源g_value线程 */

  98.         change_value_thread = rt_thread_create("change_value_thread",

  99.                                                 change_value_thread_entry,

  100.                                                 RT_NULL,

  101.                                                 512,

  102.                                                 4,

  103.                                                 20

  104.                                                 );

  105.         if(RT_NULL != change_value_thread)/* 创建成功，启动线程 */

  106.         {

  107.                 rt_thread_startup(change_value_thread);

  108.         }

  109.         else

  110.         {

  111.                 rt_kprintf("create change_value_thread failed\r\n");

  112.                 return;

  113.         }

  114.         

  115. }

复制代码
（2）观察FisSH

20190129154033207.png

（3）输入list_mutex，可以看到当前互斥量持有者

2019013009134477.png

2、防止优先级翻转示例

将创建 3 个动态线程以检查持有互斥量时，持有的线程优先级是否被调整到等待线程优先级中的最高优先级，此示例摘自《RT-Thread编程指南》。

（1）实现代码

  1. #include "main.h"

  2. #include "board.h"

  3. #include "rtthread.h"

  4. #include "data_typedef.h"

  5.  

  6. /* 指 向 线 程 控 制 块 的 指 针 */

  7. static rt_thread_t tid1 = RT_NULL;

  8. static rt_thread_t tid2 = RT_NULL;

  9. static rt_thread_t tid3 = RT_NULL;

  10. static rt_mutex_t mutex = RT_NULL;

  11.  

  12. #define THREAD_PRIORITY 10

  13. #define THREAD_STACK_SIZE 512

  14. #define THREAD_TIMESLICE 5

  15.  

  16.  

  17. int pri_inversion(void);

  18.  

  19. int main(void)

  20. {

  21.         pri_inversion();

  22.         

  23.         return 0;

  24. }

  25.  

  26. /* 线 程 1 入 口 */

  27. static void thread1_entry(void *parameter)

  28. {

  29.         /* 先 让 低 优 先 级 线 程 运 行 */

  30.         rt_thread_mdelay(100);

  31.         /* 此 时 thread3 持 有 mutex， 并 且 thread2 等 待 持有 mutex */

  32.         /* 检 查 thread2 与 thread3 的 优 先 级 情 况 */

  33.         if (tid2->current_priority != tid3->current_priority)

  34.         {

  35.                 /* 优 先 级 不 相 同， 测 试 失 败 */

  36.                 rt_kprintf("the priority of thread2 is: %d\n", tid2->current_priority);

  37.                 rt_kprintf("the priority of thread3 is: %d\n", tid3->current_priority);

  38.                 rt_kprintf("test failed.\n");

  39.                 return;

  40.         }

  41.         else

  42.         {

  43.                 rt_kprintf("the priority of thread2 is: %d\n", tid2->current_priority);

  44.                 rt_kprintf("the priority of thread3 is: %d\n", tid3->current_priority);

  45.                 rt_kprintf("test OK.\n");

  46.         }

  47. }

  48.  

  49.  

  50. /* 线 程 2 入 口 */

  51. static void thread2_entry(void *parameter)

  52. {

  53.         rt_err_t result;

  54.         

  55.         rt_kprintf("the priority of thread2 is: %d\n", tid2->current_priority);

  56.         /* 先 让 低 优 先 级 线 程 运 行 */

  57.         rt_thread_mdelay(50);

  58.         /*

  59.         * 试 图 持 有 互 斥 锁， 此 时 thread3 持 有， 应 把 thread3 的 优 先 级 提 升

  60.         * 到 thread2 相 同 的 优 先 级

  61.         */

  62.         result = rt_mutex_take(mutex, RT_WAITING_FOREVER);

  63.         if (result == RT_EOK)

  64.         {

  65.                 /* 释 放 互 斥 锁 */

  66.                 rt_mutex_release(mutex);

  67.         }

  68. }

  69.  

  70. /* 线 程 3 入 口 */

  71. static void thread3_entry(void *parameter)

  72. {

  73.         rt_tick_t tick;

  74.         rt_err_t result;

  75.         

  76.         rt_kprintf("the priority of thread3 is: %d\n", tid3->current_priority);

  77.         result = rt_mutex_take(mutex, RT_WAITING_FOREVER);

  78.         if (result != RT_EOK)

  79.         {

  80.                 rt_kprintf("thread3 take a mutex, failed.\n");

  81.         }

  82.         

  83.         /* 做 一 个 长 时 间 的 循 环，500ms */

  84.         tick = rt_tick_get();

  85.         while (rt_tick_get() - tick < (RT_TICK_PER_SECOND / 2)) ;

  86.         rt_mutex_release(mutex);

  87. }

  88.  

  89. int pri_inversion(void)

  90. {

  91.         /* 创 建 互 斥 锁 */

  92.         mutex = rt_mutex_create("mutex", RT_IPC_FLAG_FIFO);

  93.         if (mutex == RT_NULL)

  94.         {

  95.                 rt_kprintf("create dynamic mutex failed.\n");

  96.                 return -1;

  97.         }

  98.  

  99.         /* 创 建 线 程 1 */

  100.         tid1 = rt_thread_create("thread1",

  101.                                 thread1_entry,

  102.                                 RT_NULL,

  103.                                 THREAD_STACK_SIZE,

  104.                                 THREAD_PRIORITY - 1, THREAD_TIMESLICE

  105.                                 );

  106.         

  107.         if (tid1 != RT_NULL)

  108.                 rt_thread_startup(tid1);

  109.         /* 创 建 线 程 2 */

  110.         tid2 = rt_thread_create("thread2",

  111.                                 thread2_entry,

  112.                                 RT_NULL,

  113.                                 THREAD_STACK_SIZE,

  114.                                 THREAD_PRIORITY, THREAD_TIMESLICE

  115.                                 );

  116.         if (tid2 != RT_NULL)

  117.                 rt_thread_startup(tid2);

  118.         /* 创 建 线 程 3 */

  119.         tid3 = rt_thread_create("thread3",

  120.                                 thread3_entry,

  121.                                 RT_NULL,

  122.                                 THREAD_STACK_SIZE,

  123.                                 THREAD_PRIORITY + 1, THREAD_TIMESLICE

  124.                                 );

  125.         if (tid3 != RT_NULL)

  126.                 rt_thread_startup(tid3);

  127.         return 0;

  128. }

复制代码
（2）观察FinSH

20190129155132188.png

四、互斥量使用注意事项
1.  两个线程不能对同时持有同一个互斥量。如果某线程对已被持有的互斥量进行获取，则该线程会被挂起，直到持有该互斥量的线程将互斥量释放成功，其他线程才能申请这个互斥量。

2.  互斥量不能在中断服务程序中使用。

3.  RT-Thread 作为实时操作系统需要保证线程调度的实时性，尽量避免线程的长时间阻塞，因此在获得互斥量之后，应该尽快释放互斥量。

4.  持有互斥量的过程中，不得再调用 rt_thread_control()等函数接口更改持有互斥量线程的优先级。

五、互斥量和信号量的区别
下面内容来自RT-Thread社区kamutulafu的帖子：互斥量和信号量的区别

1. 互斥量用于线程的互斥，信号量用于线程的同步。

这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。

互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源

2. 互斥量值只能为0/1，信号量值可以为非负整数。

也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。

3. 互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。

参考文献：
1、[野火®]《RT-Thread 内核实现与应用开发实战—基于STM32》

2、《RT-THREAD 编程指南》



举报

回复
返回列表
*滑块验证:
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

admin手机认证
管理员

293

主题

21

回帖

3995

积分
Ta的主页发信息
更多

精彩推荐

更多

热点动态

更多

随手拍

更多

客服中心

微信扫描二维码 服务时间：周一至周日 8:30-22:00

意见反馈

admin@mcuzx.com

|网站地图

Copyright © 2008-2024 MCU智学网 https://www.mcuzx.com/ 版权所有 All Rights Reserved.

Powered by Discuz! X3.5  技术支持: MCU智学网 京ICP备18035221号-2
快速回复 返回顶部 返回列表