6-1 同步互斥与通信：有缺陷的同步示例-优快云博客

6-1 同步互斥与通信：有缺陷的同步示例

1. 什么是同步与互斥？

在多任务系统中，任务之间往往需要协调工作，这就涉及到同步（Synchronization） 和 互斥（Mutual Exclusion） 的概念。

1.1 互斥的定义

互斥简单来说就是——同一时间只能有一个任务访问某个资源。就像厕所一样，同一时间只能有一个人使用，其他人必须等待。这就叫做互斥。

1.2 同步的定义

同步则强调任务间的执行顺序。比如：

经理 B 需要汇报工作，但前提是同事 A 先完成报表。经理 B 不能跳过 A，必须等 A 先完成。这就是同步。
经理 B 想使用会议室，但A 还在开会，所以 B 必须等 A 用完。这就是同步与互斥的结合。

FreeRTOS 提供了多种方式来实现同步和互斥，但我们首先来看看错误的实现方式，理解它的缺陷，再找更优的解决方案。

2. 代码示例：错误的同步实现

我们用一个例子来演示错误的同步方式。假设有两个任务：

任务 A（计算任务）：计算一个大数值，并存入全局变量 sum。
任务 B（显示任务）：等任务 A 计算完成后，打印 sum 的值。

2.1 任务 A：计算任务

int sum = 0;
int computation_done = 0;

void TaskA(void* pvParameters) {
    sum = 0;
    for (int i = 0; i < 10000000; i++) {
        sum += i;
    }
    computation_done = 1;  // 标记计算完成
    vTaskDelete(NULL);
}

这个任务计算 0 + 1 + 2 + ... + 9999999，计算完成后，将 computation_done 变量置 1，表示任务 A 结束。

2.2 任务 B：错误的等待逻辑

void TaskB(void* pvParameters) {
    while (computation_done == 0) {
        // 在这里死循环等待任务A完成
    }
    printf("计算完成，sum = %d\n", sum);
    vTaskDelete(NULL);
}

⚠️ 这里的问题：任务 B 通过 while 循环等待 computation_done 变成 1，但它会一直占用 CPU 资源，导致系统效率低下。

3. 代码的缺陷：死等问题

3.1 问题 1：任务 B 造成 CPU 资源浪费

任务 B 死等 computation_done，它一直在 while 循环中检查变量是否为 1，但它本质上没有做任何有用的工作，只是在浪费 CPU 时间。

实际的调度情况

Task A 执行 1ms → Task B 执行 1ms (死循环) → Task A 执行 1ms → Task B 执行 1ms (死循环)...

任务 A 明明只需要 1.2 秒 计算完毕，但由于任务 B 抢占了 CPU，整个过程被拖长到了 2.5 秒！

3.2 问题 2：编译器优化导致变量不更新

有时候，即使 computation_done 被任务 A 置 1 了，但任务 B 可能仍然在循环中卡住，为什么？这是因为编译器可能会优化代码，使得 computation_done 变量不会被频繁检查。

解决办法
我们需要在变量声明前加上 volatile 关键字，确保编译器不会优化对 computation_done 的访问：

volatile int computation_done = 0;

但即使加上 volatile，死等问题依然没有解决！

4. 如何正确实现同步？

正确的方法是让任务 B 阻塞等待 任务 A 完成，而不是死等。FreeRTOS 提供了更好的方式来实现同步，例如：

任务通知（Task Notification）
二值信号量（Binary Semaphore）
事件组（Event Group）

4.1 方法 1：使用任务通知（推荐）

任务通知是 FreeRTOS 最高效 的同步方式。任务 A 计算完成后，给任务 B 发送通知，任务 B 阻塞等待 任务 A 的通知，而不是死等。

修改任务 A

void TaskA(void* pvParameters) {
    sum = 0;
    for (int i = 0; i < 10000000; i++) {
        sum += i;
    }
    xTaskNotifyGive(taskHandleB);  // 发送通知给任务B
    vTaskDelete(NULL);
}

xTaskNotifyGive(taskHandleB); 让任务 B 知道计算完成了。

修改任务 B

void TaskB(void* pvParameters) {
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);  // 等待任务A的通知
    printf("计算完成，sum = %d\n", sum);
    vTaskDelete(NULL);
}

ulTaskNotifyTake(pdTRUE, portMAX_DELAY); 让任务 B 阻塞等待 任务 A 的通知，而不是死循环。
这样任务 B 不占用 CPU，系统运行更高效！

4.2 方法 2：使用二值信号量（适用于多个任务）

如果有多个任务需要同步，可以使用二值信号量（Binary Semaphore）。

SemaphoreHandle_t xSemaphore;

void TaskA(void* pvParameters) {
    sum = 0;
    for (int i = 0; i < 10000000; i++) {
        sum += i;
    }
    xSemaphoreGive(xSemaphore);  // 释放信号量
    vTaskDelete(NULL);
}

void TaskB(void* pvParameters) {
    xSemaphoreTake(xSemaphore, portMAX_DELAY);  // 等待信号量
    printf("计算完成，sum = %d\n", sum);
    vTaskDelete(NULL);
}

xSemaphoreTake(xSemaphore, portMAX_DELAY); 让任务 B 阻塞等待 任务 A 完成。

5. 总结与提升

这节课我们学习了：
✅ 同步与互斥的基本概念：互斥是同一时间只有一个任务访问资源，同步是任务必须等待另一个任务完成。
✅ 错误的同步方式：死等会浪费 CPU 资源，导致程序效率低下。
✅ 优化的同步方式：使用任务通知（Task Notification） 或 二值信号量（Binary Semaphore），让等待任务进入阻塞状态，提高系统效率。

📌 提升建议