15_FreeRtos计数信号量优先级翻转互斥信号量

已于 2023-02-20 10:54:46 修改
阅读量536 收藏
点赞数
分类专栏： FreeRTOS 文章标签： 单片机 stm32 嵌入式硬件 FreeRTOS 物联网
于 2023-02-18 17:35:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yuanghxb/article/details/129102428
版权

目录

计数型信号量

计数型信号量相关API函数

计数型信号量实验源码

优先级翻转简介

优先级翻转实验源码

互斥信号量

互斥信号量相关API函数

互斥信号量实验源码

计数型信号量

计数型信号量相当于队列长度大于1的队列，因此计数型信号量能够容纳多个资源,这在计数型信号量被创建的时候确定的

计数型信号量适用场合:

事件计数

当每次事件发生后,在事件处理函数中释放计数型信号量(计数值+1) ,其他任务会获取计数型信号量(计数值-1),这种场合一般在创建时将初始计数值设置为 0

资源管理

信号量表示有效的资源数目。任务必须先获取信号量（信号量计数值-1）才能获取资源控制权。当计数值减为零时表示没有的资源。当任务使用完资源后，必须释放信号量（信号量计数值+1）。信号量创建时计数值应等于最大资源数目

计数型信号量相关API函数

使用计数型信号量的过程:创建计数型信号量 → 释放信号量 → 获取信号量

 计数型信号量的释放和获取与二值信号量相同!

此函数用于创建一个计数型信号量。

#definexSemaphoreCreateCounting( uxMaxCount , uxInitialCount )  \
xQueueCreateCountingSemaphore( ( uxMaxCount), ( uxlnitialCount ))

此函数用于获取信号量当前计数值大小 

#defineuxSemaphoreGetCount( xSemaphore) \

 uxQueueMessagesWaiting( (QueueHandle_t) (xSemaphore ))

计数型信号量实验源码

将设计三个任务: start_task、task1、task2

start_task :用来创建task1和task2任务

Task1:用于按键扫描,当检测到按键KEY0被按下时,释放计数型信号量

task2:每过一秒获取一次计数型信号量,当成功获取后打印信号量计数值

/**
  ******************************************************************************
  * @file           : user_mian.h
  * @brief          : V1.00
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

/* Include 包含---------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdbool.h>
#include "user_gpio.h"
#include "user_delay.h"
#include "user_rcc_config.h"
#include "user_uart.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "user_key.h"
/* Typedef 类型----------------------------------------------------------------*/
/* Define  定义----------------------------------------------------------------*/
/* Macro   宏------------------------------------------------------------------*/
/*二值信号量句柄*/
QueueHandle_t count_semphore_handle;
/* Variables 变量--------------------------------------------------------------*/ 
/* Constants 常量--------------------------------------------------------------*/
/* Function  函数--------------------------------------------------------------*/

//任务优先级
#define START_TASK_PRIO		1
//任务堆栈大小	
#define START_STK_SIZE 		128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);


//任务优先级
#define TASK1_PRIO			3
//任务堆栈大小	
#define TASK1_STK_SIZE 		100  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);


//任务优先级
#define TASK2_PRIO			3
//任务堆栈大小	
#define TASK2_STK_SIZE 		100  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);



 int main(void)
 {	

	/*配置系统中断分组为4位抢占*/
	 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
	 /*延时函数初始化*/
	 delay_init();
	/*RCC配置*/
	 Rcc_config();
	/*GPIO初始化*/ 
	 Gpio_Init();
	/*USART1初始化*/
	 Uart1_Init(9600);
	 /*创建计数型信号量最大值100,初始化值为0*/
	 count_semphore_handle = xSemaphoreCreateCounting(100,0); 
	 
	 if(count_semphore_handle != NULL)
	 {
		printf("计数型信号量创建成功初始值为0\r\n\r\n");
	 }
	 
	 /*创建开始任务*/
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
		

}
 

/*!
	\brief		开始任务函数
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    //创建任务1
    xTaskCreate((TaskFunction_t )task1,     	
                (const char*    )"task1",   	
                (uint16_t       )TASK1_STK_SIZE, 
                (void*          )NULL,				
                (UBaseType_t    )TASK1_PRIO,	
                (TaskHandle_t*  )&Task1_Handler);   
    //创建任务2
    xTaskCreate((TaskFunction_t )task2,     
                (const char*    )"task2",   
                (uint16_t       )TASK2_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2_Handler); 

				
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}


/*!
	\brief		task1释放计数型信号量
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void task1(void *pvParameters)
{
	uint8_t key = 0;
    while(1)
    {	
		/*获取按键值*/
		key = Key_Scan(0);
		
		if(key == KEY0_PRES)
		{
			if(count_semphore_handle != NULL)
			{					 
				if(xSemaphoreGive(count_semphore_handle))
				{
					taskENTER_CRITICAL();           //进入临界区
					printf("计数型信号量释放成功当前值为%d\r\n\r\n",(int)uxSemaphoreGetCount(count_semphore_handle));
				    taskEXIT_CRITICAL();            //退出临界区
				}
			}		
		}
		
		vTaskDelay(10);
    }
} 


/*!
	\brief		task2获取计数型信号量
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void task2(void *pvParameters)
{
	BaseType_t err;
    while(1)
    {
		/*获取信号量死等,进入阻塞态*/
		err = xSemaphoreTake(count_semphore_handle,portMAX_DELAY);	
		if(err == pdTRUE)
		{
			taskENTER_CRITICAL();           //进入临界区	
			printf("信号量的计数值为:%d\r\n\r\n",(int)uxSemaphoreGetCount(count_semphore_handle));		
		    taskEXIT_CRITICAL();            //退出临界区
		}
			
		vTaskDelay(1000);
    }
}



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

 

优先级翻转简介

优先级翻转:高优先级的任务反而慢执行,低优先级的任务反而优先执行

优先级翻转在抢占式内核中是非常常见的,但是在实时操作系统中是不允许出现优先级翻转的,因为优先级翻转会破坏任务的预期顺序,可能会导致未知的严重后果。

在使用二值信号量的时候,经常会遇到优先级翻转的问题。

举例:

任务H 优先级最高 任务M优先级中等  任务L优先级最低

假设任务L正在运行获取了信号量,其他2任务在阻塞状态,此时任务H就绪抢占了任务L,任务H也是获取信号量,发现信号量没有了进入阻塞态,继续执行任务L,然后任务M就绪抢占了任务L(优先级翻转了),任务M执行完后,进入阻塞态,任务H一直在等信号量所以一直在阻塞态,任务L继续运行,直到释放了信号量后,任务H才会从阻塞态变成就绪态执行。

高优先级任务被低优先级任务阻塞,导致高优先级任务迟迟得不到调度,但其他中等优先级的任务却能抢到CPU资源。从现象上看,就像是中优先级的任务比高优先级任务具有更高的优先权(即优先级翻转)

优先级翻转实验源码

在使用二值信号量的时候会存在优先级翻转的问题,本实验通过模拟的方式实现优先级翻转,观察优先级翻转对抢占式内核的影响。

将设计四个任务:start_task、high_task、middle_task, low_task

start_task:用来创建其它任务

high_task:高优先级任务,会获取二值信号量,获取成功以后打印提示信息,处理完后释放信号量

middle_task:中等优先级任务,简单的应用任务

low_task:低优先级任务,同高优先级一样的操作,不同的是低优先级任务占用信号量的时间久一点

/**
  ******************************************************************************
  * @file           : user_mian.h
  * @brief          : V1.00
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

/* Include 包含---------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdbool.h>
#include "user_gpio.h"
#include "user_delay.h"
#include "user_rcc_config.h"
#include "user_uart.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "user_key.h"
/* Typedef 类型----------------------------------------------------------------*/
/* Define  定义----------------------------------------------------------------*/
/* Macro   宏------------------------------------------------------------------*/
/*二值信号量句柄*/
QueueHandle_t semphore_handle;
/* Variables 变量--------------------------------------------------------------*/ 
/* Constants 常量--------------------------------------------------------------*/
/* Function  函数--------------------------------------------------------------*/

//任务优先级
#define START_TASK_PRIO		1
//任务堆栈大小	
#define START_STK_SIZE 		128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);


//任务优先级
#define HIGH_PRIO			4
//任务堆栈大小	
#define HIGH_STK_SIZE 		100  
//任务句柄
TaskHandle_t HIGH_Handler;
//任务函数
void high_task(void *pvParameters);


//任务优先级
#define MIDDLE_PRIO			3
//任务堆栈大小	
#define MIDDLE_STK_SIZE 		100  
//任务句柄
TaskHandle_t MIDDLE_Handler;
//任务函数
void middle_task(void *pvParameters);

//任务优先级
#define LOW_PRIO			2
//任务堆栈大小	
#define LOW_STK_SIZE 		100  
//任务句柄
TaskHandle_t LOW_Handler;
//任务函数
void low_task(void *pvParameters);


 int main(void)
 {	

	/*配置系统中断分组为4位抢占*/
	 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
	 /*延时函数初始化*/
	 delay_init();
	/*RCC配置*/
	 Rcc_config();
	/*GPIO初始化*/ 
	 Gpio_Init();
	/*USART1初始化*/
	 Uart1_Init(9600);
	 /*创建二值信号量*/
	 semphore_handle = xSemaphoreCreateBinary(); 
	 
	 if(semphore_handle == NULL)
	 {
		printf("二值信号量创建不成功\r\n\r\n");
	 }else
	 {
		printf("二值信号量创建成功\r\n\r\n");
	 }
	 /*二值释放信号量*/
	 xSemaphoreGive(semphore_handle);
	 /*创建开始任务*/
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
		

}
 

/*!
	\brief		开始任务函数
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    //创建高优先级任务
    xTaskCreate((TaskFunction_t )high_task,     	
                (const char*    )"high_task",   	
                (uint16_t       )HIGH_STK_SIZE, 
                (void*          )NULL,				
                (UBaseType_t    )HIGH_PRIO,	
                (TaskHandle_t*  )&HIGH_Handler);   
    //创建中优先级任务
    xTaskCreate((TaskFunction_t )middle_task,     
                (const char*    )"middle_task",   
                (uint16_t       )MIDDLE_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )MIDDLE_PRIO,
                (TaskHandle_t*  )&MIDDLE_Handler); 
    //创建低优先级任务
    xTaskCreate((TaskFunction_t )low_task,     
                (const char*    )"low_task",   
                (uint16_t       )LOW_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )LOW_PRIO,
                (TaskHandle_t*  )&LOW_Handler); 
				
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}


/*!
	\brief		高优先级任务
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void high_task(void *pvParameters)
{

    while(1)
    {	
		taskENTER_CRITICAL();           //进入临界区
		printf("high_task获取信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		/*获取二值信号量,并死等方式*/
		xSemaphoreTake(semphore_handle,portMAX_DELAY);
		taskENTER_CRITICAL();           //进入临界区
		printf("high_task正在运行\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		delay_xms(1000);
		/*释放二值信号量*/
		taskENTER_CRITICAL();           //进入临界区
		printf("high_task释放信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		xSemaphoreGive(semphore_handle);
		vTaskDelay(10);
    }
} 


/*!
	\brief		中优先级任务
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void middle_task(void *pvParameters)
{

    while(1)
    {
		taskENTER_CRITICAL();           //进入临界区
		printf("middle_task正在运行\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区

		vTaskDelay(1000);
    }
}



/*!
	\brief		低优先级任务
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void low_task(void *pvParameters)
{

	while(1)
	{    
		taskENTER_CRITICAL();           //进入临界区
		printf("low_task获取信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		/*获取二值信号量,并死等方式*/
		xSemaphoreTake(semphore_handle,portMAX_DELAY);
		taskENTER_CRITICAL();           //进入临界区		
		printf("low_task正在运行\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		delay_xms(3000);
		/*释放二值信号量*/
		taskENTER_CRITICAL();           //进入临界区
		printf("low_task释放信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		xSemaphoreGive(semphore_handle);
		vTaskDelay(1000);		
	
	}



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

互斥信号量

互斥信号量其实就是一个拥有优先级继承的二值信号量,在同步的应用中二值信号量最适合。互斥信号量适合用于那些需要互斥访问的应用中!

优先级继承:当一个互斥信号量正在被一个低优先级的任务持有时,如果此时有个高优先级的任务也尝试获取这个互斥信号量,那么这个高优先级的任务就会被阻塞。不过这个高优先级的任务会将低优先级任务的优先级提升到与自己相同的优先级。

 此时任务H的阻塞时间仅仅是任务L的执行时间,将优先级翻转的危害降到了最低

优先级继承并不能完全的消除优先级翻转的问题,它只是尽可能的降低优先级翻转带来的影响

注意:互斥信号量不能用于中断服务函数中,原因如下:

  1. 互斥信号量有任务优先级继承的机制,但是中断不是任务,没有任务优先级,所以互斥信号量只能用与任务中,不能用于中断服务函数。
  2. 中断服务函数中不能因为要等待互斥信号量而设置阻塞时间进入阻塞态。

互斥信号量相关API函数

使用互斥信号量:首先将宏configUSE_MUTEXES置一

使用流程:创建互斥信号量→ (task)获取信号量→ (give)释放信号量

创建互斥信号量函数

 互斥信号量的释放和获取函数与二值信号量相同！只不过互斥信号量不支持中断中调用

注意:创建互斥信号量时,会主动释放一次信号量

#define xSemaphoreCreateMutex()  xQueueCreateMutex( queueQUEUE_TYPE_MUTEX)

此函数用于创建互斥信号量

互斥信号量实验源码

在优先级翻转实验的基础,加入互斥信号量,解决优先级翻转问题

/**
  ******************************************************************************
  * @file           : user_mian.h
  * @brief          : V1.00
  ******************************************************************************
  * @attention
  *
  ******************************************************************************
  */

/* Include 包含---------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdbool.h>
#include "user_gpio.h"
#include "user_delay.h"
#include "user_rcc_config.h"
#include "user_uart.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "user_key.h"
/* Typedef 类型----------------------------------------------------------------*/
/* Define  定义----------------------------------------------------------------*/
/* Macro   宏------------------------------------------------------------------*/
/*二值信号量句柄*/
QueueHandle_t mutex_semphore_handle;
/* Variables 变量--------------------------------------------------------------*/ 
/* Constants 常量--------------------------------------------------------------*/
/* Function  函数--------------------------------------------------------------*/

//任务优先级
#define START_TASK_PRIO		1
//任务堆栈大小	
#define START_STK_SIZE 		128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);


//任务优先级
#define HIGH_PRIO			4
//任务堆栈大小	
#define HIGH_STK_SIZE 		100  
//任务句柄
TaskHandle_t HIGH_Handler;
//任务函数
void high_task(void *pvParameters);


//任务优先级
#define MIDDLE_PRIO			3
//任务堆栈大小	
#define MIDDLE_STK_SIZE 		100  
//任务句柄
TaskHandle_t MIDDLE_Handler;
//任务函数
void middle_task(void *pvParameters);

//任务优先级
#define LOW_PRIO			2
//任务堆栈大小	
#define LOW_STK_SIZE 		100  
//任务句柄
TaskHandle_t LOW_Handler;
//任务函数
void low_task(void *pvParameters);


 int main(void)
 {	

	/*配置系统中断分组为4位抢占*/
	 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
	 /*延时函数初始化*/
	 delay_init();
	/*RCC配置*/
	 Rcc_config();
	/*GPIO初始化*/ 
	 Gpio_Init();
	/*USART1初始化*/
	 Uart1_Init(9600);
	 /*创建互斥信号量,默认释放一次*/
	 mutex_semphore_handle = xSemaphoreCreateMutex(); 
	 
	 if(mutex_semphore_handle == NULL)
	 {
		printf("互斥信号量创建不成功\r\n\r\n");
	 }else
	 {
		printf("互斥信号量创建成功\r\n\r\n");
	 }
	 /*创建开始任务*/
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
		

}
 

/*!
	\brief		开始任务函数
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    //创建高优先级任务
    xTaskCreate((TaskFunction_t )high_task,     	
                (const char*    )"high_task",   	
                (uint16_t       )HIGH_STK_SIZE, 
                (void*          )NULL,				
                (UBaseType_t    )HIGH_PRIO,	
                (TaskHandle_t*  )&HIGH_Handler);   
    //创建中优先级任务
    xTaskCreate((TaskFunction_t )middle_task,     
                (const char*    )"middle_task",   
                (uint16_t       )MIDDLE_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )MIDDLE_PRIO,
                (TaskHandle_t*  )&MIDDLE_Handler); 
    //创建低优先级任务
    xTaskCreate((TaskFunction_t )low_task,     
                (const char*    )"low_task",   
                (uint16_t       )LOW_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )LOW_PRIO,
                (TaskHandle_t*  )&LOW_Handler); 
				
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}


/*!
	\brief		高优先级任务
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void high_task(void *pvParameters)
{

    while(1)
    {	
		taskENTER_CRITICAL();           //进入临界区
		printf("high_task获取信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		/*获取二值信号量,并死等方式*/
		xSemaphoreTake(mutex_semphore_handle,portMAX_DELAY);
		taskENTER_CRITICAL();           //进入临界区
		printf("high_task正在运行\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		delay_xms(1000);
		/*释放二值信号量*/
		taskENTER_CRITICAL();           //进入临界区
		printf("high_task释放信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		xSemaphoreGive(mutex_semphore_handle);
		vTaskDelay(10);
    }
} 


/*!
	\brief		中优先级任务
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void middle_task(void *pvParameters)
{

    while(1)
    {
		taskENTER_CRITICAL();           //进入临界区
		printf("middle_task正在运行\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区

		vTaskDelay(1000);
    }
}



/*!
	\brief		低优先级任务
	\param[in]	传递形参，创建任务时用户自己传入
	\param[out]	none
	\retval 	none
*/
void low_task(void *pvParameters)
{

	while(1)
	{    
		taskENTER_CRITICAL();           //进入临界区
		printf("low_task获取信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		/*获取二值信号量,并死等方式*/
		xSemaphoreTake(mutex_semphore_handle,portMAX_DELAY);
		taskENTER_CRITICAL();           //进入临界区		
		printf("low_task正在运行\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		delay_xms(3000);
		/*释放二值信号量*/
		taskENTER_CRITICAL();           //进入临界区
		printf("low_task释放信号量\r\n\r\n");
		taskEXIT_CRITICAL();            //退出临界区
		xSemaphoreGive(mutex_semphore_handle);
		vTaskDelay(1000);		
	
	}



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

Tree-gg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS计数信号量示例代码
04-07
创造两个任务，第一个任务以100ms的速度释放信号量，第二个任务以500ms的速度接收信号量并进行LED翻转，如果按照二值信号量来进行的运行，则肯定会丢失信号量。
什么是优先级反转及解决方法
动感超人_Crush
04-21 1万+
当高优先级任务正等待信号量（此信号量被一个低优先级任务拥有着）的时候，一个介于两个任务优先之间的中等优先级任务开始执行——这就会导致一个高优先级任务在等待一个低优先级任务，而低优先级任务却无法执行类似死锁的情形发生。
优先级反转问题及解决办法
上官宏竹的专栏
01-04 2465
优先级反转，是指在多线程的环境下，并且使用了信号量时，可能会出现的这样一种不合理的现象，即：高优先级任务被低优先级任务阻塞，导致高优先级任务迟迟得不到调度。但其他中等优先级的任务却能抢到CPU资源。从现象上来看，好像是中优先级的任务比高优先级任务具有更高的优先权。具体来说：当高优先级任务正等待信号量（此信号量被一个低优先级任务拥有着）的时候，一个介于两个任务优先之间的中等优先级任务开始执行——这就会导致一个高优先级任务在等待一个低优先级任务，而低优先级任务却无法执行类似死锁的情形发生。
FreeRTOS 信号量(三) ------ 优先级翻转
Bit_Dong的博客
04-27 1025
(1) 任务 H 和任务 M 处于挂起状态，等待某一事件的发生，任务 L 正在运行。(2) 某一时刻任务 L 想要访问共享资源，在此之前它必须先获得对应该资源的信号量。(3) 任务 L 获得信号量并开始使用该共享资源。(4) 由于任务 H 优先级高，它等待的事件发生后便剥夺了任务 L 的 CPU 使用权。(5) 任务 H 开始运行。(6) 任务 H 运行过程中也要使用任务 L 正在使用着的资源，由于该资源的信号量还被任务L 占用着，任务 H 只能进入挂起状态，等待任务 L 释放该信号量。(7) 任务 L 继
RTOS优先级翻转问题和解决策略
m0_58168670的博客
07-25 451
优先级翻转问题，是指在使用信号量时，可能会出现的这样一种不合理的现象，高优先级想去获取低优先级手上的信号量，但是低优先级还在执行并未去释放信号量，因此高优先级阻塞住，等待低优先级的信号量的释放，但是有不需要这个信号量的中等任务（一个介于两个任务优先之间的中等优先级任务）可以开始执行，能抢到CPU资源。这就会导致一个高优先级任务在等待一个低优先级任务，而低优先级任务却无法执行类似死锁的情形发生。如何解决优先级翻转的问题？
【整理】什么是优先级反转+有何危害+如何避免和解决
u014426028的博客
06-04 5211
背景 很早之前，学习操作系统原理时，在进程调度时，就听说过： 优先级反转 后来在了解ucOS/II时，又遇到过。 之前，也大概了解过，但是基本上是半懂不懂的。 最后又看到这个优先级反转。 所以打算去整理一下 什么是优先级反转 优先级反转，英文是priority inversion，也有其他叫法： 优先级倒置 优先级逆转 优先级翻转 先要明白背景知识： 1.操作系统的任务调度 操作系统有多个任务 任务之间谁可以得到执行，是通过任务调度来完成的 2.任务调度有多种方法（..
V5-320_FreeRTOS实验_计数信号量（中断方式）.rar
01-20
V5-320_FreeRTOS实验_计数信号量 （中断方式）
gps.rar_FreeRTOS LCD_GPS 指南针_GPS码表_freertos 信号量_gps里程
07-15
本项目设计一个类似自行车码表的产品，除了LCD显示骑行速度、骑行里程外、日期时间外，增加了GPS卫星状态、电池...任务间通过队列交互信息，通过二值信号量阻塞相关任务，完成任务调度。在空闲任务中进入低功耗模式。
V5-319_FreeRTOS实验_计数信号量.rar
01-20
V5-319_FreeRTOS实验_ 计数信号量
V5-307_FreeRTOS实验_任务优先级修改.rar
01-20
V5-307_FreeRTOS实验_任务 优先级修改
linux实时信号量优先级翻转和优先级继承
12-08
描述解决线程优先级翻转的优先级继承协议实现
FreeRTOS 互斥量 优先级反转（翻转）和优先级继承 详解
最新发布
wei_Embedded_z的博客
10-27 1019
FreeRTOS 互斥量 优先级反转（翻转）和优先级继承 详解 什么是互斥量? 什么是优先级反转(翻转)和优先级继承 互斥量相关 API函数 优先级反转(翻转)示例 使用互斥量优化优先级反转转)问题示例
FreeRTOS优先级翻转
qq_43460068的博客
02-26 679
任务优先级翻转在实时操作系统中是不允许出现的，使用互斥量的优先级继承可以解决优先级翻转的问题，但是这里只是能够降低优先级翻转带来的影响，而不能完全消除优先级翻转带来的问题，通俗的说，虽然低优先级任务优先级提高了，但是还是要等优先级低的任务执行释放操作，高优先级任务才可以得以运行，这里只是解决了介于低优先级和高优先级之间中优先级任务带来的问题。比如没有引入互斥量，高优先级需要等待L+M任务运行的时间，引入之后只有任务L运行的时间。一句话：优先级翻转可以减轻，但不能完全消除。
线程的优先级翻转
hankyt的博客
07-27 1137
线程的优先级翻转 优先级翻转 使用信号量会导致的另一个潜在问题是线程优先级翻转问题。所谓线程优先级翻转，即当一个高优先级线程试图通过某种互斥IPC对象机制访问共享资源时，如果该IPC对象已被一低优先级线程所持有，而这个低优先级线程在运行过程中可能又被其它一些中等优先级线程抢占，因此造成高优先级线程被许多具有较低优先级的线程阻塞的情况。优先级翻转会造成高优先级线程的实时性得不到保证。 如下图，由于低优先级的线程C获取到互斥量M，使得高优先级的线程A无法获取互斥量M，但中等优先级的线程B没有和A的互斥量，故它能
操作系统-优先级反转及解决方式
Johan_Joe_King的博客
08-12 5847
1、优先级反转 优先级反转，又叫优先级翻转、优先级倒置，是操作系统在基于优先级抢占方式进行进程（任务）调度的时候可能出现的一种现象。在原本的调度算法设计中，高优先级进程可以抢占低优先级的CPU资源，先执行高优先级任务。 优先级反转的概念，通俗来讲就是这样的： 再以专业的描述形式演示优先级反转现象： 优先级反转最坏的一种情况就是，一个高优先级任务很紧急，但其资源已经被一个低优先级任务...
FreeRTOS-计数信号量（三）
小阳先生
08-03 250
介绍计数信号量所用到的函数 1.创建计数信号量 SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount); 功 能: 创建一个计数信号量。 参 数: uxMaxCount: 计数信号量的最大值， 当达到这个值的时候，信号量不能再被释放。 uxInitialCount: 创建计数信号量的初始值。 返 回 值: 如果创建成功则返回一个计数信号量句柄，用于
什么是优先级反转（翻转）
热门推荐
pgs1004151212的博客
06-05 2万+
优先级反转，是指在使用信号量时，可能会出现的这样一种不合理的现象，即： 高优先级任务被低优先级任务阻塞，导致高优先级任务迟迟得不到调度。但其他中等优先级的任务却能抢到CPU资源。-- 从现象上来看，好像是中优先级的任务比高优先级任务具有更高的优先权。 具体来说：当高优先级任务正等待信号量（此信号量被一个低优先级任务拥有着）的时候，一个介于两个任务优先之间的中等优先级任务开始执行——这...
优先级反转
VictorZhang
09-05 2354
简介 优先级反转 英文名叫做 Priority Inversion，一句话概括它的意思：低优先级任务要比高优先级任务先执行。 先明白一些背景知识 1.操作系统是多任务的 2.任务之间谁都可以得到执行，是通过任务调度来完成 3.任务调度有多种算法，常见的有： 罗宾环调度算法：Round-robin scheduling algorithm 基于优先级的调度算法：Priority-controll...
FreeRTOS的任务挂起和恢复
anglebaby331的博客
10-05 4788
FreeRTOS的任务挂起和恢复很简单，分为两种情况，一种是普通的挂起恢复，一种是在终端中恢复： 普通的挂起和恢复： 普通挂起： 调用：vTaskSuspend(TaskHandle_t xTaskToSuspend);函数； 参数为：需要挂起的任务的任务句柄，如果在任务自身中挂起自身，参数可直接写为“NULL”” 普通恢复： 调用：vTaskResume(TaskHandle_t xTaskTo...
freertos计数信号量读取
09-01
在FreeRTOS中，计数信号量是一种同步机制，用于在多个任务之间传递和管理资源的访问。当一个任务需要访问某个资源时，它需要获取计数信号量，如果计数信号量的计数大于0，那么任务可以继续执行，计数信号量的计数减1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值