LiteOS互斥锁

最新推荐文章于 2025-04-29 09:03:04 发布
最新推荐文章于 2025-04-29 09:03:04 发布
阅读量1k 收藏 2
点赞数
文章标签： 鸿蒙系统 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52674444/article/details/129701673
版权
文章详细介绍了互斥锁的概念、作用以及在LiteOS操作系统中的实现和使用方法，包括互斥锁的优先级继承机制，防止优先级反转问题。文中还给出了互斥锁的创建、删除、获取和释放等函数，并提供了实际的代码示例，演示了如何在任务中使用互斥锁控制资源访问。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、基本概念

互斥锁又称互斥信号量，是一种特殊的二值信号量，常用于实现对临界资源的独占式处理。任务使用时，互斥锁处于闭锁状态，使用完毕，处于开锁状态。可以用于两个任务同时向串口发送等情况。

二、互斥锁的优先级继承机制

任务的优先级，在创建时已经指定，高优先级的任务可以打断低优先级的任务。低优先级的任务在使用互斥锁时，可能被高优先级的任务打断，那么暂时提高低优先级的任务的优先级，让它和高优先级的一样，避免了被抢占，使用完后，任务优先级恢复。

三、互斥锁的运行机制

（1）互斥锁保护的资源被占用时，无论何种优先级任务想要使用都会被阻塞

（2）正在使用互斥锁的任务1比阻塞中的任务2优先级低，暂时把1的优先级提升到2的

（3）当任务1使用完资源后会释放互斥锁，任务1的优先级恢复

（4）任务2此时可以获得互斥锁，并访问资源。

四、互斥锁的使用

4.1 互斥锁控制块
typedef struct
{
    UINT8           ucMuxStat;       /**< 互斥锁状态：OS_MUX_UNUSED或OS_MUX_USED  */
    UINT16          usMuxCount;      /**< 互斥锁持有次数 */
    UINT32          ucMuxID;         /**< 互斥锁ID*/
    LOS_DL_LIST     stMuxList;       /**< 互斥锁阻塞列表*/
    LOS_TASK_CB     *pstOwner;       /**< 任务控制块指针*/
    UINT16          usPriority;      /**< 记录互斥锁任务的初始优先级 */
} MUX_CB_S;
4.2 互斥锁错误代码

在los_mux.h文件中有定义

4.3 互斥锁函数

（1）互斥锁创建函数LOS_MuxCreate

（2）互斥锁删除函数LOS_MuxDelete

（3）互斥锁释放函数LOS_MuxPost

（4）互斥锁获取函数LOS_MuxPend

4.4 互斥锁使用注意事项

（1）两个任务不能获取同一个互斥锁

（2）不能在中断服务程序中使用

（3）获得后，尽快释放

（4）任务持有时，不允许再更改持有互斥锁的任务的优先级

（5）互斥锁和信号量的区别在于，互斥锁可以被已经持有互斥锁的任务重复获取，而不会死锁

五、互斥锁实验main文件

（1）模拟优先级翻转实验（使用二值信号量 ）

创建了三个任务，分别为高优先级、中优先级、低优先级。程序依次执行高—中—低。串口打印流程如下：

高：获取二值信号量，释放

中：运行中

低：获取二值信号量，占用非常久，此时，高堵塞

中：运行中

中：运行中

低：释放二值信号量，高就绪，LOS_TaskYield函数将低任务释放CPU，将其移到相同优先级就绪队列的队尾

高：获取二值信号量，释放

中：运行中

高：获取二值信号量，释放

低：获取二值信号量，占用非常久

……

/* LiteOS 头文件 */
#include "los_sys.h"
#include "los_task.ph"
#include "los_queue.h"
#include "los_sem.h"
/* 板级外设头文件 */
#include "bsp_usart.h"
#include "bsp_led.h"
#include "bsp_key.h"
/* 定义任务句柄 */
UINT32 HighPriority_Task_Handle;
UINT32 MidPriority_Task_Handle;
UINT32 LowPriority_Task_Handle;

/*定义二值信号量的ID*/
UINT32 BinarySem_Handle;




/* 函数声明 */
static UINT32 AppTaskCreate(void);
static UINT32 Creat_HighPriority_Task(void);
static UINT32 Creat_MidPriority_Task(void);
static UINT32 Creat_LowPriority_Task(void);

static void  HighPriority_Task(void);
static void MidPriority_Task(void);
static void LowPriority_Task(void);
static void BSP_Init(void);



int main(void)
{    
    UINT32 uwRet = LOS_OK;  //定义一个任务创建的返回值，默认为创建成功
    
    /* 板载相关初始化 */
  BSP_Init();
    

    printf("串口打印出-Sucessful-表明实验创建成功\r\n");
    /* LiteOS 内核初始化 */
    uwRet = LOS_KernelInit();
    
  if (uwRet != LOS_OK)
  {
        printf("LiteOS 核心初始化失败！失败代码0x%X\n",uwRet);
        return LOS_NOK;
  }

    uwRet = AppTaskCreate();
    if (uwRet != LOS_OK)
  {
        printf("AppTaskCreate创建任务失败！失败代码0x%X\n",uwRet);
        return LOS_NOK;
  }

  /* 开启LiteOS任务调度 */
  LOS_Start();
    
    //正常情况下不会执行到这里
    while(1);
    
}

static UINT32 AppTaskCreate(void)
{
    /* 定义一个返回类型变量，初始化为LOS_OK */
    UINT32 uwRet = LOS_OK;
    
    /*创建一个二值信号量*/
    uwRet = LOS_BinarySemCreate(1,&BinarySem_Handle);
    if(uwRet!=LOS_OK)
    {
            printf("Test_Queue队列创建失败！失败代码0x%X\n",uwRet);
            return uwRet;
    }
    
    
    
    
    uwRet = Creat_HighPriority_Task();
  if (uwRet != LOS_OK)
  {
        printf("Receive_Task任务创建失败！失败代码0x%X\n",uwRet);
        return uwRet;
  }
    
    uwRet = Creat_MidPriority_Task();
  if (uwRet != LOS_OK)
  {
        printf("Send_Task任务创建失败！失败代码0x%X\n",uwRet);
        return uwRet;
  }
    
    uwRet = Creat_LowPriority_Task();
  if (uwRet != LOS_OK)
  {
        printf("Send_Task任务创建失败！失败代码0x%X\n",uwRet);
        return uwRet;
  }
    return LOS_OK;
}



static UINT32 Creat_HighPriority_Task()
{
    //定义一个创建任务的返回类型，初始化为创建成功的返回值
    UINT32 uwRet = LOS_OK;            
    
    //定义一个用于创建任务的参数结构体
    TSK_INIT_PARAM_S task_init_param;    

    task_init_param.usTaskPrio = 3;    /* 任务优先级，数值越小，优先级越高 */
    task_init_param.pcName = " HighPriority_Task";/* 任务名 */
    task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC) HighPriority_Task;/* 任务函数入口 */
    task_init_param.uwStackSize = 1024;        /* 堆栈大小 */

    uwRet = LOS_TaskCreate(& HighPriority_Task_Handle, &task_init_param);/* 创建任务 */
    return uwRet;
}


static UINT32 Creat_MidPriority_Task()
{
    // 定义一个创建任务的返回类型，初始化为创建成功的返回值
    UINT32 uwRet = LOS_OK;                
    TSK_INIT_PARAM_S task_init_param;

    task_init_param.usTaskPrio = 4;    /* 任务优先级，数值越小，优先级越高 */
    task_init_param.pcName = "MidPriority_Task";    /* 任务名*/
    task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)MidPriority_Task;/* 任务函数入口 */
    task_init_param.uwStackSize = 1024;    /* 堆栈大小 */
    
    uwRet = LOS_TaskCreate(&MidPriority_Task_Handle, &task_init_param);/* 创建任务 */

    return uwRet;
}

static UINT32 Creat_LowPriority_Task()
{
    // 定义一个创建任务的返回类型，初始化为创建成功的返回值
    UINT32 uwRet = LOS_OK;                
    TSK_INIT_PARAM_S task_init_param;

    task_init_param.usTaskPrio = 5;    /* 任务优先级，数值越小，优先级越高 */
    task_init_param.pcName = "LowPriority_Task";    /* 任务名*/
    task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)LowPriority_Task;/* 任务函数入口 */
    task_init_param.uwStackSize = 1024;    /* 堆栈大小 */
    
    uwRet = LOS_TaskCreate(&LowPriority_Task_Handle, &task_init_param);/* 创建任务 */

    return uwRet;
}


static void  HighPriority_Task(void)
{

    UINT32 uwRet = LOS_OK;
  /* 任务都是一个无限循环，不能返回 */
    while(1)
    {
        uwRet = LOS_SemPend(BinarySem_Handle, LOS_WAIT_FOREVER);
        //获取二值信号量(BinarySem_Handle，未获取到会一直等待
    if (uwRet == LOS_OK)
  {
        printf("高优先级任务运行中\n");
  }
        
        LED1_TOGGLE;
        LOS_SemPost(BinarySem_Handle);//释放二值信号量BinarySem_Handle
        LOS_TaskDelay(1000);
    }
}

static void MidPriority_Task(void)
{
    UINT32 uwRet = LOS_OK;
  /* 任务都是一个无限循环，不能返回 */
    while(1)
    {
            printf("中优先级任务运行中\n");
            LOS_TaskDelay(1000);
        
    }
}
static void LowPriority_Task(void)
{
    UINT32 uwRet = LOS_OK;
    
    static uint32_t i;
  /* 任务都是一个无限循环，不能返回 */
    while(1)
    {
        uwRet = LOS_SemPend(BinarySem_Handle, LOS_WAIT_FOREVER);
        //获取二值信号量(BinarySem_Handle，未获取到会一直等待
        if (uwRet == LOS_OK)
        {
            printf("低优先级任务运行中\n");
        }
        LED2_TOGGLE;
        
        for (i = 0;i<200000;i++){//模拟低优先级任务占用信号量
            
            LOS_TaskYield();//放弃剩余时间片，进行一次任务切换
        }
        printf("低优先任务释放信号量\r\n");
        
        LOS_SemPost(BinarySem_Handle);//释放二值信号量
        
        
            LOS_TaskDelay(1000);
        
    }
}
/*******************************************************************
  * @ 函数名  ： BSP_Init
  * @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
  * @ 参数    ：   
  * @ 返回值  ： 无
  ******************************************************************/
static void BSP_Init(void)
{
    /*
     * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
     * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
     * 都统一用这个优先级分组，千万不要再分组，切忌。
     */
    NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
    
    /* LED 初始化 */
    LED_GPIO_Config();

    /* 串口初始化    */
    USART_Config();
    /* KEY初始化 */
    Key_GPIO_Config();
}


/******************************END OF FILE*******************/

（2）互斥锁实验

低优先级任务运行时，中优先级任务无法抢占低优先级的任务

/* LiteOS 头文件 */
#include "los_sys.h"
#include "los_task.ph"
#include "los_queue.h"
#include "los_sem.h"
#include "los_mux.h"

/* 板级外设头文件 */
#include "bsp_usart.h"
#include "bsp_led.h"
#include "bsp_key.h"
/* 定义任务句柄 */
UINT32 HighPriority_Task_Handle;
UINT32 MidPriority_Task_Handle;
UINT32 LowPriority_Task_Handle;



/*定义互斥锁的ID变量*/
UINT32 Mutex_Handle;



/* 函数声明 */
static UINT32 AppTaskCreate(void);
static UINT32 Creat_HighPriority_Task(void);
static UINT32 Creat_MidPriority_Task(void);
static UINT32 Creat_LowPriority_Task(void);

static void  HighPriority_Task(void);
static void MidPriority_Task(void);
static void LowPriority_Task(void);
static void BSP_Init(void);



int main(void)
{    
    UINT32 uwRet = LOS_OK;  //定义一个任务创建的返回值，默认为创建成功
    
    /* 板载相关初始化 */
  BSP_Init();
    

    printf("串口打印出-Sucessful-表明实验创建成功\r\n");
    /* LiteOS 内核初始化 */
    uwRet = LOS_KernelInit();
    
  if (uwRet != LOS_OK)
  {
        printf("LiteOS 核心初始化失败！失败代码0x%X\n",uwRet);
        return LOS_NOK;
  }

    uwRet = AppTaskCreate();
    if (uwRet != LOS_OK)
  {
        printf("AppTaskCreate创建任务失败！失败代码0x%X\n",uwRet);
        return LOS_NOK;
  }

  /* 开启LiteOS任务调度 */
  LOS_Start();
    
    //正常情况下不会执行到这里
    while(1);
    
}

static UINT32 AppTaskCreate(void)
{
    /* 定义一个返回类型变量，初始化为LOS_OK */
    UINT32 uwRet = LOS_OK;
    
    /*创建一个互斥锁*/
    uwRet = LOS_MuxCreate(&Mutex_Handle);
    if(uwRet!=LOS_OK)
    {
            printf("Mutex创建失败！失败代码0x%X\n",uwRet);
            return uwRet;
    }
    
    
    
    
    uwRet = Creat_HighPriority_Task();
  if (uwRet != LOS_OK)
  {
        printf("Receive_Task任务创建失败！失败代码0x%X\n",uwRet);
        return uwRet;
  }
    
    uwRet = Creat_MidPriority_Task();
  if (uwRet != LOS_OK)
  {
        printf("Send_Task任务创建失败！失败代码0x%X\n",uwRet);
        return uwRet;
  }
    
    uwRet = Creat_LowPriority_Task();
  if (uwRet != LOS_OK)
  {
        printf("Send_Task任务创建失败！失败代码0x%X\n",uwRet);
        return uwRet;
  }
    return LOS_OK;
}



static UINT32 Creat_HighPriority_Task()
{
    //定义一个创建任务的返回类型，初始化为创建成功的返回值
    UINT32 uwRet = LOS_OK;            
    
    //定义一个用于创建任务的参数结构体
    TSK_INIT_PARAM_S task_init_param;    

    task_init_param.usTaskPrio = 3;    /* 任务优先级，数值越小，优先级越高 */
    task_init_param.pcName = " HighPriority_Task";/* 任务名 */
    task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC) HighPriority_Task;/* 任务函数入口 */
    task_init_param.uwStackSize = 1024;        /* 堆栈大小 */

    uwRet = LOS_TaskCreate(& HighPriority_Task_Handle, &task_init_param);/* 创建任务 */
    return uwRet;
}


static UINT32 Creat_MidPriority_Task()
{
    // 定义一个创建任务的返回类型，初始化为创建成功的返回值
    UINT32 uwRet = LOS_OK;                
    TSK_INIT_PARAM_S task_init_param;

    task_init_param.usTaskPrio = 4;    /* 任务优先级，数值越小，优先级越高 */
    task_init_param.pcName = "MidPriority_Task";    /* 任务名*/
    task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)MidPriority_Task;/* 任务函数入口 */
    task_init_param.uwStackSize = 1024;    /* 堆栈大小 */
    
    uwRet = LOS_TaskCreate(&MidPriority_Task_Handle, &task_init_param);/* 创建任务 */

    return uwRet;
}

static UINT32 Creat_LowPriority_Task()
{
    // 定义一个创建任务的返回类型，初始化为创建成功的返回值
    UINT32 uwRet = LOS_OK;                
    TSK_INIT_PARAM_S task_init_param;

    task_init_param.usTaskPrio = 5;    /* 任务优先级，数值越小，优先级越高 */
    task_init_param.pcName = "LowPriority_Task";    /* 任务名*/
    task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)LowPriority_Task;/* 任务函数入口 */
    task_init_param.uwStackSize = 1024;    /* 堆栈大小 */
    
    uwRet = LOS_TaskCreate(&LowPriority_Task_Handle, &task_init_param);/* 创建任务 */

    return uwRet;
}


static void  HighPriority_Task(void)
{

    UINT32 uwRet = LOS_OK;
  /* 任务都是一个无限循环，不能返回 */
    while(1)
    {
        uwRet = LOS_MuxPend(Mutex_Handle, LOS_WAIT_FOREVER);
        //获取Mutex，未获取到会一直等待
    if (uwRet == LOS_OK)
  {
        printf("高优先级任务运行中\n");
  }
        
        LED1_TOGGLE;
        LOS_MuxPost(Mutex_Handle);//释放
        LOS_TaskDelay(1000);
    }
}

static void MidPriority_Task(void)
{
    UINT32 uwRet = LOS_OK;
  /* 任务都是一个无限循环，不能返回 */
    while(1)
    {
            printf("中优先级任务运行中\n");
            LOS_TaskDelay(1000);
        
    }
}
static void LowPriority_Task(void)
{
    UINT32 uwRet = LOS_OK;
    
    static uint32_t i;
  /* 任务都是一个无限循环，不能返回 */
    while(1)
    {
        uwRet = LOS_MuxPend(Mutex_Handle, LOS_WAIT_FOREVER);
        //获取Mutex，未获取到会一直等待
        if (uwRet == LOS_OK)
        {
            printf("低优先级任务运行中\n");
        }
        LED2_TOGGLE;
        
        for (i = 0;i<200000;i++){//模拟低优先级任务占用信号量
            
            LOS_TaskYield();//放弃剩余时间片，进行一次任务切换
        }
        printf("低优先任务释放互斥锁\r\n");
        
        LOS_MuxPost(Mutex_Handle);//释放互斥锁
        
        
            LOS_TaskDelay(1000);
        
    }
}
/*******************************************************************
  * @ 函数名  ： BSP_Init
  * @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
  * @ 参数    ：   
  * @ 返回值  ： 无
  ******************************************************************/
static void BSP_Init(void)
{
    /*
     * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
     * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
     * 都统一用这个优先级分组，千万不要再分组，切忌。
     */
    NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
    
    /* LED 初始化 */
    LED_GPIO_Config();

    /* 串口初始化    */
    USART_Config();
    /* KEY初始化 */
    Key_GPIO_Config();
}


/******************************END OF FILE*******************/
瑆玥琼
关注
LiteOS内核教学：互斥锁在嵌入式系统中的应用
PixeGO的博客
09-23 145
为了解决这个问题，嵌入式系统中常用的同步机制之一是互斥锁。在上面的示例中，我们创建了两个任务task1和task2，并使用互斥锁来保护共享资源的访问。当一个任务获取到互斥锁时，其他任务必须等待该任务释放互斥锁后才能获取它。它确保只有一个任务可以同时访问被保护的资源，其他任务必须等待当前任务释放锁之后才能获得对资源的访问权限。通过使用互斥锁，我们可以确保多个任务之间对共享资源的访问是安全和有序的，避免数据不一致或竞争条件的发生。本文将介绍互斥锁在LiteOS内核中的应用，并提供相应的源代码示例。
LiteOS内核教程04 | 互斥锁 嵌入式
WangWEel的博客
09-26 108
为了保证数据的完整性和任务的正确执行，需要使用同步机制来协调任务之间的访问。信号量是一种常用的同步机制，在本文中我们将介绍如何使用信号量来实现任务的互斥访问和资源的共享。本文介绍了LiteOS中使用信号量实现任务的互斥访问和资源的共享的方法。通过使用信号量，可以有效地解决多任务之间的资源竞争问题，保证任务的正确执行。在实际的嵌入式开发中，可以根据需求灵活地使用信号量来实现任务间的同步与协作。LiteOS是一个轻量级的嵌入式操作系统，提供了信号量机制用于任务的同步和资源的管理。一、信号量的基本概念。
【嵌入式开发】LiteOS互斥锁机制解析：保障多任务系统中共享资源访问的稳定性和实时性LiteOS互斥
04-28
内容概要：本文详细介绍了LiteOS互斥锁在嵌入式开发中的应用，旨在帮助开发者理解和掌握互斥锁的工作原理及其重要性。LiteOS是华为开发的一款轻量级操作系统，专为物联网设计，具有快速启动、节能等特性。互斥锁作为一种同步机制，确保多任务环境中只有一个任务能访问共享资源，防止数据冲突。文章深入剖析了互斥锁的基本概念、优先级继承机制以及运作流程，包括创建、获取、释放和删除互斥锁的具体步骤。文中还展示了互斥锁在智能家居系统和工业控制系统中的实际应用场景，并强调了使用互斥锁时的注意事项，如避免重复加锁、不在中断服务程序中使用互斥锁、及时释放锁等。最后，文章讨论了死锁和优先级反转问题的原因及解决方案。 适合人群：对嵌入式开发有兴趣的工程师，尤其是从事物联网、智能家居、工业控制等领域开发的技术人员。 使用场景及目标：①帮助开发者理解LiteOS互斥锁的工作原理及其在多任务环境中的重要性；②指导开发者如何在实际项目中正确使用互斥锁，避免数据冲突和优先级翻转问题；③提供具体的代码示例和应用场景分析，便于开发者在实际开发中应用所学知识。 阅读建议：本文内容详尽，涵盖了从理论到实践的各个方面。建议读者在阅读过程中结合代码示例进行实践操作，理解互斥锁的具体实现和使用方法。同时，注意互斥锁使用的注意事项，避免常见错误，确保系统稳定性和可靠性。
LiteOS 互斥锁
xinghunlove123的博客
05-30 1489
参考： 【野火】物联网操作系统 LiteOS 开发实战指南 Huawei LiteOS | 中文网 5. 互斥锁 5.1 基本概念 互斥锁又叫互斥信号量，或者叫互斥量，是一种特殊的二值信号量 支持互斥所有权 常用于实现对**临界资源的独占式处理，**任意时刻，互斥锁的状态只有两种，开锁或者闭锁，互斥锁被持有，则为闭锁状态，其他任务无法对该互斥锁进行开锁或持有，当任务释放互斥锁，该...
HI3861学习笔记（9）——LiteOS(CMSIS-RTOS2)互斥锁
Leung的博客
07-11 1869
一、简介 1.1 互斥锁 在多任务环境下，往往存在多个任务竞争同一共享资源的应用场景，互斥锁可被用于对共享资源的保护从而实现独占式访问。互斥锁(mutex)又称互斥型信号量，是一种特殊的二值信号量，用于实现对共享资源的独占式处理。另外，Huawei LiteOS提供的互斥锁通过优先级继承算法，解决了优先级翻转问题。 1.2 互斥锁的使用方式 在任意时刻，互斥锁的状态只有两种：开锁和闭锁。 当有任务持有时，互斥锁处于闭锁状态，这个任务获得该互斥锁的所有权。 当该任务释放它时，该互斥锁被开锁，任务失去该互斥锁
一文带你剖析LiteOS互斥锁Mutex源代码
华为云官方博客
04-12 1450
摘要：多任务环境下会存在多个任务访问同一公共资源的场景，而有些公共资源是非共享的临界资源，只能被独占使用。LiteOS使用互斥锁来避免这种冲突，互斥锁是一种特殊的二值性信号量，用于实现对临界资源的独占式处理。
鸿蒙Hi3861学习九-Huawei LiteOS-M（互斥锁）
qq_26226375的博客
05-08 1418
创建互斥锁。不可在中断中使用。attr：属性，自定义内存时使用。默认NULL锁标识符。
【鸿蒙内核分析】LiteOS-M内核源码分析：互斥锁Mutex
2401_88547687的博客
12-02 684
在文件定义的互斥锁控制块结构体LosMuxCB，源代码如下，结构体成员的解释见注释部分。/**< 互斥锁状态：OS_MUX_UNUSED, OS_MUX_USED *//**< 锁被持有的次数 *//**< 互斥锁Id *//**< 互斥锁双向链表 *//**< 当前持有锁的任务 *//**< 当前持有锁的任务的优先级，为避免优先级翻转，可能会更改任务的优先级，此时有备份的作用 */} LosMuxCB;系统支持创建多少互斥锁是根据开发板情况使用宏定义的，互斥锁muxId是UINT32类型的，
解锁LiteOS互斥锁：嵌入式开发的同步神器
最新发布
大雨淅淅的博客
04-29 696
在物联网飞速发展的今天，轻量级操作系统扮演着至关重要的角色，LiteOS 便是其中的佼佼者。LiteOS 是华为面向物联网领域开发的一款基于实时内核的轻量级操作系统 ，其内核大小小于 10KB，具有节能特性和快速启动能力，启动时间可达毫秒级。它支持如 NB-IoT、Wi-Fi、以太网、BLE、Zigbee 等多种物联网协议，并能接入不同的云平台，具备 “零配置”“自发现” 和 “自组网” 能力，使得智能硬件开发更为简单，有力地推动了万物互联互通的实现。
OpenHarmony5.0南向开发：互斥锁-内核通信机制（LiteOS-M）
hanyanyou的博客
08-04 1108
互斥锁又称互斥型信号量，是一种特殊的二值性信号量，用于实现对共享资源的独占式处理。
基于STM32F103移植华为LiteOS—互斥锁
morecrazylove的博客
05-05 1061
基本概念 互斥锁又称互斥型信号量，是一种特殊的二值性信号量，用于实现对共享资源的独占式处理。 任意时刻互斥锁的状态只有两种，开锁或闭锁。当有任务持有时，互斥锁处于闭锁状态，这个任务获得该互斥锁的所有权。当该任务释放它时，该互斥锁被开锁，任务失去该互斥锁的所有权。当一个任务持有互斥锁时，其他任务将不能再对该互斥锁进行开锁或持有。 多任务环境下往往存在多个任务竞争同一共享资源的应用场景，互斥锁可被用于对共享资源的保护从而实现独占式访问。另外，互斥锁可以解决信号量存在的优先级翻转问题。 Huawei LiteOS
鸿蒙南向开发指南：内核通信运行机制（互斥锁）
v_maniu110的博客
07-17 1029
互斥锁又称互斥型信号量，是一种特殊的二值性信号量，用于实现对共享资源的独占式处理。
RT-Thread 内核应用开发消息队列实验
liwuxing的专栏
01-17 655
消息队列实验 消息队列实验是在RT-Thread中创建了3个线程，2个是发送消息线程，1个是获取消息线程。3个线程独立运行，key1按下时key1线程发送消息1；key2按下时key2线程连接发送消息2共20次，key2线程发送频率大于接收并打印输出的速率。Key1、key2线程假如发送消息不成功，就把返回的错误情代码在串口打印出来。接收线程用于获取消息线程，在消息队列没有消息之前一直等待消息，一旦获取到消息就把消息打印在串口调试助手里。 实验时，先按下key2，由于发送频率大于接收线...
HCIA-HarmonyOS设备开发认证V2.0-轻量系统内核基础-互斥锁mux
嵌入式软硬件设计/方案设计
02-15 1750
LiteOS-M 互斥锁Los_Mux
LiteOS内核开发（二）
weixin_51641707的博客
04-16 998
本章将介绍LiteOS内核中的任务管理模块 1. 基本概念 从系统上来说，任务是资源竞争的最小单元，可以使用或等待CPU的系统资源，独立运行。HUWEI LITEOS可以给用户提供多个任务，实现任务通信和切换。任务管理是LiteOS不可裁剪极小内核的一部分功能，主要支持任务的创建，删除，延迟，挂起，恢复等功能，同时支持锁定和解锁任务调度。支持抢占式调度和时间片轮转。 2. 相关属性 任务状态： 一般来说，一个任务可以具有为几种不同的状态，即就绪态，阻塞态，运行态和结束态，这四种状态之间的转换关系如
基于Linux的kfifo移植到STM32（支持os的互斥访问）
杰杰的博客
09-29 3570
基于Linux的kfifo移植到STM32（支持os的互斥访问） 关于kfifo kfifo是内核里面的一个First In First Out数据结构，它采用环形循环队列的数据结构来实现；它提供一个无边界的字节流服务，最重要的一点是，它使用并行无锁编程技术，即当它用于只有一个入队线程和一个出队线程的场情时，两个线程可以并发操作，而不需要任何加锁行为，就可以保证kfifo的线程安全。 具体什么是...
HarmonyOS内核（Lite-mOS）开发——任务管理
butnotif的博客
02-05 884
HarmonyOS内核（Lite-mOS）开发——任务管理
OpenHarmony——内核IPC机制数据结构解析
OpenHarmony_dev的博客
09-08 1137
管理具体消息队列的数据块，内核初始化时调用OsQueueInit()创建，并依次挂载到双向环形链表g_freeQueueList中，此时控制块状态为OS\_QUEUE\_UNUSED，队列控制块用来保存队列的状态，队列长度、消息长度、队列ID、队列头尾位置和等待读写的任务列表，内核就是根据这些信息来管理消息队列和任务完成对消息读写等操作。关于OpenHarmony 内核的内容，之前我还介绍了内核对象队列的算法以及OpenHarmony LiteOS-M 内核事件的运作机制，感兴趣的读者可以点击阅读：《
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值