FreeRTOS_信号量-CSDN博客

但还是要引入互斥量的概念。

互斥量与二进制信号量相比#xff0c;能够多实现如下两个功能#xff1a…互斥量概述

在博文“

但还是要引入互斥量的概念。

互斥量与二进制信号量相比能够多实现如下两个功能

防止优先级反转问题解决递归上锁/解锁问题

普通互斥量具有优先级继承功能解决优先级反转问题递归锁具有优先级继承功能、能够解决递归上锁/解锁问题、解决谁上锁谁才能解锁的问题

优先级反转

假设任务A、B、C的优先级为1、2、3。

在程序开始时A进行上锁之后B运行抢断的A之后C运行抢断了B。

在C中想获得锁但A已经上锁所以C进入了阻塞释放了CPU。

这时B继续运行但不解锁从而导致C被B抢占即高优先级的任务是否能继续执行由低优先级的任务决定。

优先级继承

在C获得锁之后进入阻塞状态同时执行上锁的任务A会继承C的优先级3从而进行执行。

当A执行完解锁后A优先级的优先级变回原来的优先级1。

之后C获得锁不再阻塞C继续执行执行完成之后B运行。

在低优先级任务上锁高优先级任务获得锁阻塞之后低优先级任务继承高优先级任务的优先级的操作叫做优先级继承。

递归上锁/解锁

fun(){xSemaphoreTake(SemaphoreHandleTest,portMAX_DELAY);/*

*//*

*/xSemaphoreGive(SemaphoreHandleTest);/*

void

*param){while(1){xSemaphoreTake(SemaphoreHandleTest,portMAX_DELAY);/*

*//*

*/fun();xSemaphoreGive(SemaphoreHandleTest);/*

*/}

在上述代码中任务1首先进行了上锁之后调用了fun函数。

在fun函数中又进行了上锁但这时已经上锁所以就阻塞在了fun函数中。

最终导致Task1无法执行完成fun函数也就无法执行解锁函数形成死锁。

递归锁

使用递归锁可以解决上述问题。

递归锁的作用是如果开始时为A来上锁那么在上锁之后A依旧可以进行调用上锁函数进行上锁而不会进入阻塞状态。

但不管怎样上锁之后都要解锁即上锁多少次就要解锁多少次上锁与解锁一

除此之外递归锁还可以满足谁上锁谁才有权力解锁的问题。

而信号量和普通互斥锁并不能实现这个功能。

相关配置

互斥量在创建后与二进制信号量不同互斥量初始值为1二进制信号量初始值为0

获取/释放互斥量

存入函数返回值成功返回pdPASS在当前计数值最大计数值时会存入失败

xSemaphore

xSemaphoreCreateRecursiveMutex()/*

宏定义

xSemaphoreCreateRecursiveMutex()

\xQueueCreateMutex(

queueQUEUE_TYPE_RECURSIVE_MUTEX

)/*

存入函数返回值成功返回pdPASS在当前计数值最大计数值时会存入失败

xSemaphore

与二进制信号量实现该功能相比代码方面的差异只在初始化不同其他代码都没有进行修改

创建二进制信号量初始值自动设置为

xSemaphoreGive(SemaphoreHandleTest);

创建互斥量初始值自动设置为

”内容的描述来进行编写代码。

这里使用二进制信号量与互斥量进行运行结果的对比。

QueueHandle_t

*/xSemaphoreTake(SemaphoreHandleTest,portMAX_DELAY);/*

*/taskA_flag

0;for(i0;i20;i){printf(%d,%d,%d,taskA_flag,taskB_flag,taskC_flag);taskA_flag

1;taskB_flag

*/xSemaphoreGive(SemaphoreHandleTest);}

void

*/xSemaphoreTake(SemaphoreHandleTest,portMAX_DELAY);/*

C任务执行一段时间

*/xSemaphoreGive(SemaphoreHandleTest);}

int

xHandleTask3;prvSetupHardware();SerialPortInit();printf(UART

TEST\r\n);/*

*/xSemaphoreGive(SemaphoreHandleTest);xTaskCreate(TaskAFunction,TaskA,100,(void*)NULL,1,xHandleTask1);xTaskCreate(TaskBFunction,TaskB,100,(void*)NULL,2,xHandleTask2);xTaskCreate(TaskCFunction,TaskC,100,(void*)NULL,3,xHandleTask3);vTaskStartScheduler();return

这三个标志位来判断当前任务是谁在运行。

通过逻辑分析仪显示出这三个变量的电平来分析抢占关系。

2阶段中BC调用延时处于阻塞态因此A运行。

在2-3阶段中A运行了一段时间后B的延时结束B开始抢占A进行运行。

在2-3阶段中B运行了一段时间后C的延时结束C开始抢占B进行运行。

以上是正常的抢占流程。

在C抢占B之后尝试获取信号量但信号量已经被A所获取还未进行释放因此C进入了阻塞状态之后B进行抢占到CPU继续执行。

但B的优先级高于AA不能够释放信号量这样就导致了C永远处于阻塞态只有当B释放CPUA才能释放信号量从而C才可以运行这样就产生了优先级反转的问题。

2阶段中BC调用延时处于阻塞态因此A运行。

在2-3阶段中A运行了一段时间后B的延时结束B开始抢占A进行运行。

在2-3阶段中B运行了一段时间后C的延时结束C开始抢占B进行运行。

以上是正常的抢占流程。

在C抢占B之后尝试获取互斥量但互斥量已经被A所获取还未进行释放因此A进行优先级的继承此时A的优先级变成了3即4

5阶段。

在5-6阶段中A的优先级为3执行完成打印工作后对互斥量进行了解锁这时任务A的优先级变回原来的优先级1C任务抢占A开始执行。

3、谁上锁谁才能解锁实验

普通互斥量和二进制信号量并未实现谁上锁谁才能解锁这里使用普通互斥量与递归锁来进行对比来验证递归锁能够实现谁上锁谁才能解锁的功能。

具体代码实现如下

xSemaphoreTake(SemaphoreHandleTest,portMAX_DELAY);

xSemaphoreGive(SemaphoreHandleTest);/*

*/xSemaphoreTakeRecursive(SemaphoreHandleTest,portMAX_DELAY);printf(%s,(char*)param);xSemaphoreGiveRecursive(SemaphoreHandleTest);vTaskDelay(1);}

void

*param){vTaskDelay(1);while(1){//

while(1){

if(xSemaphoreTake(SemaphoreHandleTest,0)

pdFALSE){

xSemaphoreGive(SemaphoreHandleTest);

}else{

xSemaphoreGive(SemaphoreHandleTest);/*

*/while(1){/*

*/if(xSemaphoreTakeRecursive(SemaphoreHandleTest,0)

pdFALSE){xSemaphoreGiveRecursive(SemaphoreHandleTest);}else{break;}}printf(this

break\r\n);xSemaphoreGiveRecursive(SemaphoreHandleTest);vTaskDelay(1);}

}int

xHandleTask3;prvSetupHardware();SerialPortInit();printf(UART

TEST\r\n);//

xSemaphoreCreateRecursiveMutex();xTaskCreate(PrintFunction,TaskA,100,(void*)this

TaskA\r\n,1,xHandleTask1);xTaskCreate(PrintFunction,TaskB,100,(void*)this

TaskB\r\n,1,xHandleTask2);xTaskCreate(BreakSemaphoreTask,TaskC,100,(void*)NULL,1,xHandleTask3);vTaskStartScheduler();return

可以看到打印结果乱套了。

这是因为在A上锁之后C任务去放进去了一把锁导致B任务原来在阻塞突然获得了锁执行了B任务中的printf。

因此互斥量并没有实现谁上锁谁才能够解锁的功能。

可以看到打印变得非常正常。

这是因为递归锁可以实现谁上锁谁才能够解锁因此不能够再C中解开A的锁从而执行结果变得正常。

4、递归上锁实验

xSemaphoreTake(SemaphoreHandleTest,portMAX_DELAY);

xSemaphoreGive(SemaphoreHandleTest);/*

*/xSemaphoreTakeRecursive(SemaphoreHandleTest,portMAX_DELAY);for(i0;i5;i){/*

递归上锁上锁之后再上一次锁

*/xSemaphoreTakeRecursive(SemaphoreHandleTest,portMAX_DELAY);printf(lock:%i\r\n,i);xSemaphoreGiveRecursive(SemaphoreHandleTest);}printf(%s,(char*)param);xSemaphoreGiveRecursive(SemaphoreHandleTest);vTaskDelay(1);}

运行结果如下

可以看到lock0~4正常打印说明并未产生阻塞的情况递归锁可以递归上锁。