FreeRTOS学习——同步互斥
FreeRTOS学习——同步互斥
目录
- FreeRTOS学习——同步互斥
-
- 一、概念
-
- 1.1 同步
- 1.2 互斥
- 二、示例——有缺陷的同步
- 三、示例——优化有缺陷的同步
- 四、示例——有缺陷的互斥
- 五、总结
一、概念
1.1 同步
在FreeRTOS中，同步是指任务之间按照某种规则进行协调和按序执行的过程。其目的是保证任务或线程之间的有序交互，使它们能够按照预期的顺序完成各自的操作或实现特定的约束条件。常见的同步场景包括等待其他任务完成、等待某个条件满足、协调任务之间的依赖关系等。
FreeRTOS提供了多种同步机制，例如信号量、互斥量、消息队列等，用于实现任务之间的同步。这些机制可以帮助任务之间进行协作，以确保它们按照一定的顺序、时机和约束进行执行。
同步机制在FreeRTOS中非常重要，因为它们可以确保系统的正确性和稳定性。如果没有同步机制，任务之间可能会出现竞争条件，导致系统行为不可预测。通过使用同步机制，FreeRTOS可以确保任务之间的正确交互，从而提高系统的可靠性和性能。
1.2 互斥
FreeRTOS中，互斥是一种同步机制，用于保护共享资源，确保任务访问这些资源时的原子性，避免数据错误。具体来说，互斥是指在多任务环境中，运行特定代码段时确保数据的一致性和完整性，避免多个任务同时访问和修改共享资源导致错误的发生。它通过互斥量（又称互斥信号量）来实现，互斥量是一种特殊的二值信号量，用于实现对临界资源的独占式处理。任意时刻互斥量的状态只有两种，开锁或闭锁。当互斥量被任务持有时，该互斥量处于闭锁状态，这个任务获得互斥量的所有权。当该任务释放这个互斥量时，该互斥量处于开锁状态，任务失去该互斥量的所有权。当一个任务持有互斥量时，其他任务将不能再对该互斥量进行开锁或持有。持有该互斥量的任务也能够再次获得这个锁而不被挂起，这就是递归访问，也就是递归互斥量的特性。
一句话理解同步与互斥：我等你用完厕所，我再用厕所。
什么叫同步？就是：哎哎哎，我正在用厕所，你等会。
什么叫互斥？就是：哎哎哎，我正在用厕所，你不能进来。
同步与互斥经常放在一起讲，是因为它们之的关系很大， “互斥”操作可以使用“同步”来实现。我“等”你用完厕所，我再用厕所。这不就是用“同步”来实现“互斥”吗？
二、示例——有缺陷的同步
实验目的：计算ul变量累加到1000000需要多长时间
具体实现：
创建2个Task，定义一个全局变量taskFlag，当taskFlag等于1时表示Task1正在运行，当taskFlag等于0时表示Task2正在运行
Task1：
- Task1中定义一个累加变量ul
- 第一次运行Task1（开始累加ul）时记录系统此刻tick时间vstartTime
- 当ul>1000000（ul累加完毕）时记录系统此刻tick时间vendTime
- 累加完毕后将累加结束标志endFlag置位，将vendTime-vstartTime时间赋值给全局变量vtotleTime
Task2：
- 判断全局变量endFlag是否置位
- 若endFlag置位，打印出vtotleTime
实验代码：
#define mainDELAY_LOOP_COUNT 1000000
volatile TickType_t vtotleTime;
volatile TickType_t vstartTime = 0, vendTime = 0;
volatile bool endFlag = FALSE;
volatile bool endLock = FALSE;
volatile uint8_t taskFlag = 0;
void vTask1( void *pvParameters )
{
volatile uint32_t ul; /* volatile用来避免被优化掉 */
vstartTime = xTaskGetTickCount();
/* 打印任务1的信息 */
printf( "Count start: %d\r\n",vstartTime );
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task1在运行 */
taskFlag = 1;
/* 延迟一会(比较简单粗暴) */
if(endLock == FALSE)
{
ul++;
if((ul > mainDELAY_LOOP_COUNT) && (endFlag != TRUE))
{
endFlag = TRUE;
vendTime = xTaskGetTickCount();
vtotleTime = vendTime - vstartTime;
vTaskDelay(10);
}
}
}
}
void vTask2( void *pvParameters )
{
volatile uint32_t ul; /* volatile用来避免被优化掉 */
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task2在运行 */
taskFlag = 0;
if(endFlag == TRUE)
{
endFlag = FALSE;
printf( "Count end: %d\r\nTotle time: %d\r\n",vendTime, vtotleTime);
endLock = TRUE;
}
}
}
int main( void )
{
prvSetupHardware();
xTaskCreate(vTask1, "Task 1", 1000, NULL, 1, NULL);
xTaskCreate(vTask2, "Task 2", 1000, NULL, 1, NULL);
/* 启动调度器 */
vTaskStartScheduler();
/* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
return 0;
}
运行结果：
实验分析：从taskFlag分析，Task1在累加ul变量时，Task2仍然在运行，仍然耗费CPU资源，理论上分析如果在ul累加期间，使Task2任务挂起，ul从0累加到1000000耗时会减少一半。
三、示例——优化有缺陷的同步
基于“二”中的示例进行优化
优化思路：使用队列通信代替Task2对全局变量endFlag的判断，队列传输数据结构体：
typedef struct
{
TickType_t startTime;
TickType_t endTime;
TickType_t stopFlag;
}TIME;
- main中创建一个队列
- Task2中接收队列，队列中没有数据时Task2阻塞，队列中有数据时打印出endTime-startTime，即ul累加到1000000耗时
- Task1中累加ul，当ul累加到1000000时将数据结构体通过队列发送给Task2
实验代码：
#define mainDELAY_LOOP_COUNT 1000000
typedef struct
{
TickType_t startTime;
TickType_t endTime;
TickType_t stopFlag;
}TIME;
void vTask1( void *pvParameters )
{
TIME time1;
volatile uint32_t ul; /* volatile用来避免被优化掉 */
volatile TickType_t buf[10];
time1.stopFlag = FALSE;
T1 = xTaskGetTickCount();
time1.startTime = xTaskGetTickCount();
/* 打印任务1的信息 */
printf( "Count start: %d\r\n",time1.startTime);
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task1在运行 */
taskFlag = 1;
/* 延迟一会(比较简单粗暴) */
ul++;
if((ul > mainDELAY_LOOP_COUNT) && time1.stopFlag != TRUE)
{
T2 = xTaskGetTickCount();
time1.endTime = xTaskGetTickCount();
time1.stopFlag = TRUE;
xQueueSend(task1Handle, &time1, NULL);
}
}
}
void vTask2( void *pvParameters )
{
TIME time2;
volatile uint32_t ul; /* volatile用来避免被优化掉 */
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task2在运行 */
taskFlag = 0;
xQueueReceive(task1Handle, &time2, portMAX_DELAY);
if(time2.stopFlag == TRUE)
{
printf( "Count end: %d\r\nTotle time: %d\r\n",time2.endTime, time2.endTime - time2.startTime);
time2.stopFlag = FALSE;
}
}
}
int main( void )
{
prvSetupHardware();
xTaskCreate(vTask1, "Task 1", 1000, NULL, 1, NULL);
xTaskCreate(vTask2, "Task 2", 1000, NULL, 1, NULL);
task1Handle = xQueueCreate(1,sizeof(TIME));
/* 启动调度器 */
vTaskStartScheduler();
/* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
return 0;
}
运行结果：
实验分析：使用队列时，Task2未接收到队列的数据时会进入挂起状态，不会再占用CPU资源，Task1往队列发送数据时，会同时将Task2从挂起状态改变为就绪或者运行状态。
四、示例——有缺陷的互斥
实验目的：不同任务访问相同临界资源（比如全局变量）时有缺陷的互斥
仍然使用“二”中的示例，进行简单的修改，在“二”的代码中Task1累加完ul变量得到累加耗时后使用了vTaskDelay函数使Task1挂起，如果不使用vTaskDelay函数就会出现有缺陷的互斥现象
实验代码：
#define mainDELAY_LOOP_COUNT 1000000
volatile TickType_t vtotleTime;
volatile TickType_t vstartTime = 0, vendTime = 0;
volatile bool endFlag = FALSE;
volatile bool endLock = FALSE;
volatile uint8_t taskFlag = 0;
void vTask1( void *pvParameters )
{
volatile uint32_t ul; /* volatile用来避免被优化掉 */
vstartTime = xTaskGetTickCount();
/* 打印任务1的信息 */
printf( "Count start: %d\r\n",vstartTime );
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task1在运行 */
taskFlag = 1;
/* 延迟一会(比较简单粗暴) */
if(endLock == FALSE)
{
ul++;
if((ul > mainDELAY_LOOP_COUNT) && (endFlag != TRUE))
{
endFlag = TRUE;
vendTime = xTaskGetTickCount();
vtotleTime = vendTime - vstartTime;
//vTaskDelay(10);
}
}
}
}
void vTask2( void *pvParameters )
{
volatile uint32_t ul; /* volatile用来避免被优化掉 */
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task2在运行 */
taskFlag = 0;
if(endFlag == TRUE)
{
endFlag = FALSE;
printf( "Count end: %d\r\nTotle time: %d\r\n",vendTime, vtotleTime);
endLock = TRUE;
}
}
}
int main( void )
{
prvSetupHardware();
xTaskCreate(vTask1, "Task 1", 1000, NULL, 1, NULL);
xTaskCreate(vTask2, "Task 2", 1000, NULL, 1, NULL);
/* 启动调度器 */
vTaskStartScheduler();
/* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
return 0;
}
运行结果：
实验分析：从运行结果来看，Task2打印了2次，理论上从代码分析，程序运行到Task2的打印时，应该是先将endFlag设置为了FALSE，但是打印了2次说明endFlag的值没有写入成功，单步调试分析一下：
将endFlag值在Watch1中显示，在Task2打印处设置一个断点，全速运行
从代码来看Task1也会修改endFlag的值，在Task1中计算累计时间处再打一个断点，全速运行
再次全速运行到Task2中打印处
再次全速运行再也不会听到断点处，这就是Task2中打印了2次的详细步骤。
缺陷原理：
1、当运行到Task2打印处是，endFlag被更改为FALSE
2、但是Task2还未来得及更改完endLock就切换到了Task1
3、Task1中又将endFlag更改为TRUE
4、切换到Task2时再次打印了一遍
5、这次在切换到Task1之前修改完了endLock的值
6、再切换到Task1时不会再更改endFlag的值了
修改代码逻辑可以避免Task2打印2次：
修改前：
void vTask2( void *pvParameters )
{
volatile uint32_t ul; /* volatile用来避免被优化掉 */
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task2在运行 */
taskFlag = 0;
if(endFlag == TRUE)
{
endFlag = FALSE;
printf( "Count end: %d\r\nTotle time: %d\r\n",vendTime, vtotleTime);
endLock = TRUE;
}
}
}
修改后：
void vTask2( void *pvParameters )
{
volatile uint32_t ul; /* volatile用来避免被优化掉 */
/* 任务函数的主体一般都是无限循环 */
for( ;; )
{
/* 表示Task2在运行 */
taskFlag = 0;
if(endFlag == TRUE)
{
endLock = TRUE;
endFlag = FALSE;
printf( "Count end: %d\r\nTotle time: %d\r\n",vendTime, vtotleTime);
}
}
}
这样修改可以避免Task2打印2次，因为在打印时Task2已经完成了对endLock和endFlag的修改，但是同样存在缺陷，原因是：
C语言中1条给全局变量的赋值语句并不是程序的最小运行单位，C语言的本质是汇编，从Task2的汇编码可以看到，将endFlag的值赋值为0分为3个步骤：
假设在赋值过程中运行完汇编第二步后就切换了任务，其他任务对该临界资源也进行了修改，再切换到当前任务时该被修改的临界资源又被修改了。因此这种修改也并不是万无一失的。
补充一个办法：当前任务需要修改临界资源时，现将系统所有中断关闭，暂停任务调度和中断，修改完临界资源后再将中断恢复，恢复任务调度和中断。
但是这种方法关闭中断也对系统有一定的风险！
五、总结
正确使用互斥与同步，FreeRTOS提供的方法是安全可靠的，比如队列、信号量、互斥量、任务通知等等，就像“三、优化有缺陷的同步”一样，使用FreeRTOS提供的方法同样可以优化有缺陷的互斥。
