RTOS 实时系统 - 信号量如何确保一次只有一个任务可以访问某个资源

本文由 简悦 SimpRead 转码， 原文地址 triot.blog.youkuaiyun.com

---

  信号量（Semaphore）是一种同步机制，用于控制对共享资源的访问。信号量可以确保一次只有一个任务可以访问某个资源，从而避免多个任务同时访问同一资源导致的竞争条件。下面是信号量如何控制对共享资源的访问的具体步骤和示例：

一、信号量的工作原理

1. 初始化：创建一个信号量，并设置其初始计数值。
2. 获取（Acquire）：任务在访问共享资源之前，尝试获取信号量。如果信号量的计数值大于 0，则任务成功获取信号量，计数值减 1；如果计数值为 0，则任务会被阻塞，直到有其他任务释放信号量。
3. 释放（Release）：任务在完成对共享资源的访问后，释放信号量，信号量的计数值加 1。如果有其他任务正在等待该信号量，那么其中一个任务会被唤醒并继续执行。

二、二值信号量（Binary Semaphore）

  二值信号量是最简单的信号量形式，其计数值只能是 0 或 1。它类似于互斥锁（Mutex），但有一些细微的区别，如不支持递归锁定和优先级继承等特性。

[示例代码]
  以下是一个使用 CMSIS-RTOS v2 API 的示例，展示了如何使用信号量来控制对共享资源的访问：

#include "cmsis_os2.h"
#include <stdio.h>
 
// 信号量属性
const osSemaphoreAttr_t semaphore_attr = {
    .name = "MySemaphore",
};
 
// 共享资源
int shared_resource = 0;
 
// 任务函数
void Task1(void *argument) 
{
    osSemaphoreId_t semaphore_id = (osSemaphoreId_t)argument;
 
    while (1) 
	{
        // 获取信号量
        osStatus_t status = osSemaphoreAcquire(semaphore_id, osWaitForever);
		
        if (status == osOK) 
		{
            printf("Task 1: Acquired semaphore\n");
 
            // 访问共享资源
            shared_resource++;
            printf("Task 1: Shared resource value: %d\n", shared_resource);
 
            // 释放信号量
            status = osSemaphoreRelease(semaphore_id);
            if (status == osOK) 
			{
                printf("Task 1: Released semaphore\n");
            } 
			else 
			{
                // 处理释放信号量失败的情况
                while (1);
            }
        } 
		else 
		{
            // 处理获取信号量失败的情况
            while (1);
        }
 
        // 延迟一段时间
        osDelay(500);
    }
}
 
void Task2(void *argument) 
{
    osSemaphoreId_t semaphore_id = (osSemaphoreId_t)argument;
 
    while (1) 
	{
        // 获取信号量
        osStatus_t status = osSemaphoreAcquire(semaphore_id, osWaitForever);
        if (status == osOK) 
		{
            printf("Task 2: Acquired semaphore\n");
 
            // 访问共享资源
            shared_resource--;
            printf("Task 2: Shared resource value: %d\n", shared_resource);
 
            // 释放信号量
            status = osSemaphoreRelease(semaphore_id);
            if (status == osOK) 
			{
                printf("Task 2: Released semaphore\n");
            } 
			else 
			{
                // 处理释放信号量失败的情况
                while (1);
            }
        } 
		else 
		{
            // 处理获取信号量失败的情况
            while (1);
        }
 
        // 延迟一段时间
        osDelay(500);
    }
}
 
int main(void) 
{
    // 初始化 RTOS
    osKernelInitialize();
 
    // 创建二值信号量
    osSemaphoreId_t semaphore_id = osSemaphoreNew(1, 1, &semaphore_attr);
 
    if (semaphore_id == NULL) 
	{
        // 处理信号量创建失败的情况
        while (1);
    }
 
    // 创建任务
    const osThreadAttr_t thread_attr1 = 
	{
        .name = "Task1",
        .stack_size = 512,
        .priority = (osPriority_t)osPriorityNormal,
    };
 
    osThreadId_t thread_id1 = osThreadNew(Task1, (void *)semaphore_id, &thread_attr1);
 
    if (thread_id1 == NULL) 
	{
        // 处理任务创建失败的情况
        while (1);
    }
 
    const osThreadAttr_t thread_attr2 = 
	{
        .name = "Task2",
        .stack_size = 512,
        .priority = (osPriority_t)osPriorityNormal,
    };
 
    osThreadId_t thread_id2 = osThreadNew(Task2, (void *)semaphore_id, &thread_attr2);
 
    if (thread_id2 == NULL) 
	{
        // 处理任务创建失败的情况
        while (1);
    }
 
    // 启动 RTOS 调度器
    osKernelStart();
 
    // 不会到达这里
    while (1);
}

三、解释

1. 初始化：

   • 在 main 函数中，我们创建了一个二值信号量 semaphore_id，初始计数值为 1。

2. 任务定义：

   • Task1 和 Task2 是两个任务，它们都试图访问同一个共享资源 shared_resource。

3. 获取信号量：

   • 在每个任务中，首先调用 osSemaphoreAcquire 来获取信号量。如果信号量的计数值大于 0，则任务成功获取信号量，计数值减 1；否则，任务会被阻塞，直到有其他任务释放信号量。

4. 访问共享资源：

   • 一旦任务成功获取了信号量，就可以安全地访问共享资源。在这个示例中，Task1 增加 shared_resource 的值，而 Task2 减少 shared_resource 的值。

5. 释放信号量：

   • 任务在完成对共享资源的访问后，调用 osSemaphoreRelease 释放信号量，信号量的计数值加 1。如果有其他任务正在等待该信号量，那么其中一个任务会被唤醒并继续执行。

通过这种方式，信号量确保了一次只有一个任务可以访问共享资源，从而避免了竞争条件。

四、运行结果

  由于 Task1 和 Task2 是并发执行的，并且使用了信号量来保护共享资源 shared_resource，因此可以确保在同一时间只有一个任务可以访问和修改 shared_resource。以下是可能的运行结果示例：

Task 1: Acquired semaphore

Task 1: Shared resource value: 1

Task 1: Released semaphore

Task 2: Acquired semaphore

Task 2: Shared resource value: 0

Task 2: Released semaphore

Task 1: Acquired semaphore

Task 1: Shared resource value: 1

Task 1: Released semaphore

Task 2: Acquired semaphore

Task 2: Shared resource value: 0

Task 2: Released semaphore

五、输出结果解释

• 信号量的作用：信号量确保 shared_resource 只能被一个任务在某一时刻访问。例如，当 Task1 获取了信号量并增加 shared_resource 的值时，Task2 必须等待 Task1 释放信号量后才能获取信号量并减少 shared_resource 的值。
• 交替执行：由于 Task1 和 Task2 的优先级相同，且每次操作后都有 500 毫秒的延迟，所以它们会交替执行。每次 Task1 增加 shared_resource 的值，Task2 就会减少 shared_resource 的值，从而保持 shared_resource 的值在 0 和 1 之间变化。
• 输出顺序：具体的输出顺序可能会有所不同，因为任务调度是基于 RTOS 的调度策略，但总体上 Task1 和 Task2 会交替执行，每个任务在获取和释放信号量时会有相应的输出。

六、注意事项

• 死锁预防：确保每个任务在完成对共享资源的操作后总是释放信号量，以避免死锁。
• 错误处理：在实际应用中，应该更好地处理获取和释放信号量失败的情况，而不是简单地进入无限循环。

通过这种方式，信号量有效地保护了共享资源，确保了数据的一致性和完整性。