21ic电子技术开发论坛»论坛首页 › 综合技术交流 › 物联网技术 › 小熊派华为物联网操作系统LiteOS内核教程05-互斥锁 ...
返回列表 发新帖

小熊派华为物联网操作系统LiteOS内核教程05-互斥锁

[复制链接]
 楼主| 小熊派开源社区 发表于 2020-2-25 10:50 | 显示全部楼层 |阅读模式
内核, 物联网, liteOS, 华为, 操作系统
1. LiteOS的互斥锁

1.1. 互斥锁
在多任务环境下，往往存在多个任务竞争同一共享资源的应用场景，互斥锁可被用于对共享资源的保护从而实现独占式访问。互斥锁(mutex)又称互斥型信号量，是一种特殊的二值信号量，用于实现对共享资源的独占式处理。另外，Huawei LiteOS提供的互斥锁通过优先级继承算法，解决了优先级翻转问题。

1.2. 互斥锁的使用方式
多任务环境下会存在多个任务访问同一公共资源的场景，而有些公共资源是非共享的，需要任务进行独占式处理。
互斥锁怎样来避免这种冲突呢？
在任意时刻，互斥锁的状态只有两种：开锁和闭锁。
当有任务持有时，互斥锁处于闭锁状态，这个任务获得该互斥锁的所有权。当该任务释放它时，该互斥锁被开锁，任务失去该互斥锁的所有权。当一个任务持有互斥锁时，其他任务将不能再对该互斥锁进行开锁或持有。
那么，当一个互斥锁为加锁状态时，此时其他任务如果想访问这个公共资源则会被阻塞，直到互斥锁被持有该锁的任务释放后，其他任务才能重新访问该公共资源，此时互斥锁再次上锁，如此确保同一时刻只有一个任务正在访问这个公共资源，保证了公共资源操作的完整性。

1.3. 互斥锁的使用场景
互斥锁可以提供任务之间的互斥机制，用来防止两个任务在同一时刻访问相同的共享资源。
除此之外，互斥锁还可以被用于防止多任务同步时造成优先级翻转的问题。

2. 互斥锁API
Huawei LiteOS 系统中的互斥锁模块为用户提供创建/删除互斥锁、获取/释放互斥锁的功能。
Huawei LiteOS 系统中提供的互斥锁 API 都是以 LOS 开头，但是这些 API 使用起来比较复杂，所以本文中我们使用 Huawei IoT Link SDK 提供的统一API接口进行实验，这些接口底层已经使用 LiteOS 提供的API实现，对用户而言更为简洁，API列表如下：
osal的api接口声明在<osal.h>中，使用相关的接口需要包含该头文件，关于函数的详细参数请参考该头文件的声明。
相关的接口定义在osal.c中，基于LiteOS的接口实现在 liteos_imp.c文件中：
接口名
功能描述
osal_mutex_create
创建互斥锁
osal_mutex_del
删除互斥锁
osal_mutex_lock
获取互斥锁(上锁)
osal_mutex_unlock
释放互斥锁(解锁)

2.1. osal_mutex_create
osal_mutex_create接口用于创建一个互斥锁，其接口原型如下：
复制
  1. bool_t  osal_mutex_create(osal_mutex_t *mutex)
    

  2. {
    

  3.     bool_t ret = false;
    


  4. 

  5.     if((NULL != s_os_cb) &&(NULL != s_os_cb->ops) &&(NULL != s_os_cb->ops->mutex_create))
    

  6.     {
    

  7.         ret = s_os_cb->ops->mutex_create(mutex);
    

  8.     }
    


  9. 

  10.     return ret;
    


  11. 

  12. }


该接口的参数说明如下表：

参数
描述
mutex
互斥锁索引ID的地址
返回值
false - 创建失败
返回值
true - 创建成功

2.2. osal_mutex_del
osal_mutex_del接口用于删除一个互斥锁，其接口原型如下：
复制
  1. bool_t  osal_mutex_del(osal_mutex_t mutex)
    

  2. {
    

  3.     bool_t ret = false;
    


  4. 

  5.     if((NULL != s_os_cb) &&(NULL != s_os_cb->ops) &&(NULL != s_os_cb->ops->mutex_del))
    

  6.     {
    

  7.         ret = s_os_cb->ops->mutex_del(mutex);
    

  8.     }
    


  9. 

  10.     return ret;
    


  11. 

  12. }

该接口的参数说明如下表：

参数
描述
mutex
互斥锁索引ID
返回值
false - 删除失败
返回值
true - 删除成功

2.3. osal_mutex_lock
osal_mutex_lock接口用于获取一个互斥锁，其接口原型如下：
复制
  1. bool_t  osal_mutex_lock(osal_mutex_t mutex)
    

  2. {
    

  3.     bool_t ret = false;
    


  4. 

  5.     if((NULL != s_os_cb) &&(NULL != s_os_cb->ops) &&(NULL != s_os_cb->ops->mutex_lock))
    

  6.     {
    

  7.         ret = s_os_cb->ops->mutex_lock(mutex);
    

  8.     }
    


  9. 

  10.     return ret;
    


  11. 

  12. }

参数
描述
mutex
互斥锁索引ID
返回值
false - 申请失败
返回值
true - 申请成功

2.4. osal_mutex_unlock
osal_mutex_unlock接口用于释放一个互斥锁，如果有任务阻塞等待该互斥锁，则唤醒最早被阻塞的任务，该任务进入就绪态，并进行调度。
其接口原型如下：
复制
  1. bool_t  osal_mutex_unlock(osal_mutex_t mutex)
    

  2. {
    

  3.     bool_t ret = false;
    


  4. 

  5.     if((NULL != s_os_cb) &&(NULL != s_os_cb->ops) &&(NULL != s_os_cb->ops->mutex_unlock))
    

  6.     {
    

  7.         ret = s_os_cb->ops->mutex_unlock(mutex);
    

  8.     }
    


  9. 

  10.     return ret;
    

  11. }


该接口的参数说明如下表：

参数
描述
mutex
互斥锁索引ID
返回值
false - 释放失败
返回值
true - 释放成功

3. 动手实验 —— 使用互斥锁进行资源保护

实验内容
本实验中将创建两个任务，一个低优先级任务task1，一个高优先级任务task2，两个任务之间依次对共享资源上锁、操作、解锁，在串口终端中观察两个任务的运行情况。
实验代码
首先打开上一篇使用的 HelloWorld 工程，基于此工程进行实验。

在Demo文件夹右击，新建文件夹osal_kernel_demo用于存放内核的实验文件（如果已有请忽略这一步）。
接下来在此文件夹中新建一个实验文件 osal_mutex_demo.c，开始编写代码：


复制
  1. /* 使用osal接口需要包含该头文件 */
    

  2. #include <osal.h>
    


  3. 

  4. /* 任务优先级宏定义（shell任务的优先级为10） */
    

  5. #define USER_TASK1_PRI  12  //低优先级
    

  6. #define USER_TASK2_PRI  11  //高优先级
    


  7. 

  8. /* 共享资源 */
    

  9. uint32_t public_value = 0;
    


  10. 

  11. /* 互斥锁索引ID */
    

  12. osal_mutex_t public_value_mutex;
    


  13. 

  14. /* 任务task1入口函数 */
    

  15. static int user_task1_entry()
    

  16. {
    

  17.     while(1)
    

  18.     {
    

  19.         /* 尝试获取互斥锁 */
    

  20.         if(true == osal_mutex_lock(public_value_mutex))
    

  21.         {
    

  22.             /* 获取到互斥锁，对共享资源进行操作 */
    

  23.             printf("\r\ntask1: lock a mutex.\r\n");
    

  24.             public_value  = 10;
    

  25.             printf("task1: public_value = %ld.\r\n", public_value);
    


  26. 

  27.             /* 对共享资源操作完毕，释放互斥锁 */
    

  28.             printf("task1: unlock a mutex.\r\n\r\n");
    

  29.             osal_mutex_unlock(public_value_mutex);
    


  30. 

  31.             /* 满足条件则结束任务 */
    

  32.             if(public_value > 100)
    

  33.                 break;
    

  34.             
    

  35.         }
    

  36.     }
    


  37. 

  38.     /* while(1)会执行结束，所以需要返回值 */
    

  39.     return 0;
    

  40. }
    


  41. 

  42. /* 任务task2入口函数 */
    

  43. static int user_task2_entry()
    

  44. {
    

  45.     while (1)
    

  46.     {
    

  47.         /* 尝试获取互斥锁 */
    

  48.        if(true == osal_mutex_lock(public_value_mutex))
    

  49.         {
    

  50.             /* 获取到互斥锁，对共享资源进行操作 */
    

  51.             printf("\r\ntask2: lock a mutex.\r\n");
    

  52.             public_value  = 5; 
    

  53.             printf("task2: public_value = %ld.\r\n", public_value);
    


  54. 

  55.             /* 对共享资源操作完毕，释放互斥锁 */
    

  56.             printf("task2: unlock a mutex.\r\n\r\n");
    

  57.             osal_mutex_unlock(public_value_mutex);
    

  58.             
    

  59.             /* 满足条件则结束任务 */
    

  60.             if(public_value > 90)
    

  61.                 break;
    

  62.             /* 优先级较高，需要挂起一下，让task1获取到互斥锁，否则task2再次上锁，形成死锁 */
    

  63.             osal_task_sleep(10);
    

  64.         }
    

  65.     }
    


  66. 

  67.     /* while(1)会执行结束，所以需要返回值 */
    

  68.     return 0;
    

  69. }
    


  70. 

  71. /* 标准demo启动函数，函数名不要修改，否则会影响下一步实验 */
    

  72. int standard_app_demo_main()
    

  73. {
    

  74.     /* 创建互斥锁public_value_mutex */
    

  75.     osal_mutex_create(&public_value_mutex);
    


  76. 

  77.     /* 创建任务task1 */
    

  78.     osal_task_create("user_task1",user_task1_entry,NULL,0x400,NULL,USER_TASK1_PRI);
    


  79. 

  80.     /* 创建任务task2 */
    

  81.     osal_task_create("user_task2",user_task2_entry,NULL,0x400,NULL,USER_TASK2_PRI);
    


  82. 

  83.     return 0;
    

  84. }


编写完成之后，要将我们编写的 osal_mutex_demo.c文件添加到makefile中，加入整个工程的编译：
这里有个较为简单的方法，直接修改Demo文件夹下的user_demo.mk配置文件，添加如下代码：
复制
  1. #example for osal_mutex_demo
    

  2. ifeq ($(CONFIG_USER_DEMO), "osal_mutex_demo")    
    

  3.            user_demo_src  = ${wildcard $(TOP_DIR)/targets/STM32L431_BearPi/Demos/osal_kernel_demo/osal_mutex_demo.c}
    

  4. endif

添加位置如图：


这段代码的意思是：
如果 CONFIG_USER_DEMO 宏定义的值是osal_mutex_demo，则将osal_mutex_demo.c文件加入到makefile中进行编译。
那么，如何配置 CONFIG_USER_DEMO 宏定义呢？在工程根目录下的.sdkconfig文件中的末尾即可配置：


因为我们修改了mk配置文件，所以点击重新编译按钮进行编译，编译完成后点击下载按钮烧录程序。

实验现象
程序烧录之后，即可看到程序已经开始运行，在串口终端中可看到实验的输出内容：
复制
  1. linkmain:V1.2.1 AT 11:30:59 ON Nov 28 2019
    


  2. 

  3. WELCOME TO IOT_LINK SHELL
    


  4. 

  5. LiteOS:/>
    

  6. task2: lock a mutex.
    

  7. task2: public_value = 5.
    

  8. task2: unlock a mutex.
    


  9. 

  10. task1: lock a mutex.
    

  11. task1: public_value = 15.
    

  12. task1: unlock a mutex.
    


  13. 


  14. 

  15. task1: lock a mutex.
    

  16. task1: public_value = 25.
    

  17. task1: unlock a mutex.
    


  18. 

  19. task2: lock a mutex.
    

  20. task2: public_value = 30.
    

  21. task2: unlock a mutex.
    


  22. 

  23. task1: lock a mutex.
    

  24. task1: public_value = 40.
    

  25. task1: unlock a mutex.
    


  26. 

  27. task1: lock a mutex.
    

  28. task1: public_value = 50.
    

  29. task1: unlock a mutex.
    


  30. 

  31. task2: lock a mutex.
    

  32. task2: public_value = 55.
    

  33. task2: unlock a mutex.
    


  34. 

  35. task1: lock a mutex.
    

  36. task1: public_value = 65.
    

  37. task1: unlock a mutex.
    


  38. 

  39. task1: lock a mutex.
    

  40. task1: public_value = 75.
    

  41. task1: unlock a mutex.
    


  42. 

  43. task2: lock a mutex.
    

  44. task2: public_value = 80.
    

  45. task2: unlock a mutex.
    


  46. 

  47. task1: lock a mutex.
    

  48. task1: public_value = 90.
    

  49. task1: unlock a mutex.
    


  50. 

  51. task1: lock a mutex.
    

  52. task1: public_value = 100.
    

  53. task1: unlock a mutex.
    


  54. 

  55. task2: lock a mutex.
    

  56. task2: public_value = 105.

可以看到，系统启动后，首先打印版本号，串口shell的优先级为10，最先打印shell信息，接下来task1先创建，但是优先级较低，所以后创建的task2抢占执行，task2获取到互斥锁，对共享资源进行操作，操作完毕解锁，然后主动挂起，task1获取到互斥锁，对共享资源进行另一个操作，操作完毕解锁，在task1操作的时候，task2早已挂起完毕，但是获取不到互斥锁，所以挂起等待，在task1解锁后，堵塞的task2被唤醒开始执行。


小熊派开源社区，专注于IoT、AI、5G等前沿技术分享，关注“小熊派开源社区”微信公众号，获取更多资料教程。


--------------------------------------------------END---------------------------------------------------


回复 赏

举报

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

本版积分规则

小熊派开源社区

12

主题

13

帖子

0

粉丝
快速回复 返回顶部 返回列表