FreeRTOS系列---信号量详解

理解 FreeRTOS 的信号量（Semaphore）实现需要从 队列的复用机制 和 信号量专用逻辑 两个层面分析。FreeRTOS 的信号量（包括二值信号量、计数信号量、互斥量）均基于队列实现，但在队列基础上做了特化处理。以下是结合源码（以 FreeRTOS v10.4.3 为例）的详细讲解：

---

1. 信号量的本质：复用队列

1.1 信号量与队列的关系

FreeRTOS 的信号量是通过 长度为 1 且 item 大小为 0 的队列 实现的：

• 二值信号量：队列长度 1，数据大小为 0，仅传递“存在/不存在”状态。
• 计数信号量：队列长度 N（最大计数值），数据大小为 0，记录可用资源数量。
• 互斥量（Mutex）：在队列基础上增加了 优先级继承 机制。

1.2 关键源码定义

源码位置：FreeRTOS/Source/include/semphr.h

// 信号量句柄实际是队列句柄的别名
typedef QueueHandle_t SemaphoreHandle_t;

// 互斥量控制块（继承队列控制块）
typedef struct QueueDefinition Queue_t;
typedef struct SemaphoreData
{
    Queue_t xQueue;         // 队列基类
    UBaseType_t uxRecursiveCallCount; // 递归互斥量调用计数
} SemaphoreData_t;

---

2. 二值信号量实现

2.1 创建二值信号量

源码位置：xQueueCreateBinary()

SemaphoreHandle_t xSemaphoreCreateBinary( void )
{
    // 创建队列：长度 1，item 大小 0
    QueueHandle_t xHandle = xQueueGenericCreate( 1, 0, queueQUEUE_TYPE_BINARY_SEMAPHORE );
    
    // 初始化信号量为“不可用”状态
    if( xHandle != NULL )
        xQueueGenericSend( xHandle, NULL, 0, queueSEND_TO_BACK );
    return xHandle;
}

• 关键点：初始化时队列为空（不可用），通过发送（xSemaphoreGive()）填充队列使其变为可用。

2.2 信号量的 Take 和 Give

• Take（获取）：调用 xQueueReceive() 从队列中读取数据（即使数据大小为 0）。
• Give（释放）：调用 xQueueSend() 向队列写入数据。

// xSemaphoreTake() 源码简化
BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait )
{
    return xQueueGenericReceive( xSemaphore, NULL, xTicksToWait, pdFALSE );
}

// xSemaphoreGive() 源码简化
BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore )
{
    return xQueueGenericSend( xSemaphore, NULL, 0, queueSEND_TO_BACK );
}

---

3. 计数信号量实现

3.1 创建计数信号量

源码位置：xQueueCreateCountingSemaphore()

SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount )
{
    // 创建队列：长度 uxMaxCount，item 大小 0
    QueueHandle_t xHandle = xQueueCreateCountingSemaphore( uxMaxCount, uxInitialCount );
    
    // 初始化时填充 uxInitialCount 个“资源”
    for( UBaseType_t i = 0; i < uxInitialCount; i++ )
        xQueueSend( xHandle, NULL, 0 );
    return xHandle;
}

• 关键点：队列长度表示最大计数值，队列中已有消息数表示当前可用资源数。

---

4. 互斥量（Mutex）实现

4.1 互斥量的特殊逻辑

• 优先级继承：当低优先级任务持有互斥量，而高优先级任务尝试获取时，临时提升低优先级任务的优先级。
• 递归锁：允许同一任务多次获取互斥量（需调用 xSemaphoreCreateRecursiveMutex()）。

4.2 互斥量创建

源码位置：xQueueCreateMutex()

SemaphoreHandle_t xSemaphoreCreateMutex( void )
{
    QueueHandle_t xHandle = xQueueCreateMutex( queueQUEUE_TYPE_MUTEX );
    return xHandle;
}

// 内部实现：queue.c
QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )
{
    Queue_t *pxNewQueue = xQueueGenericCreate( 1, 0, ucQueueType );
    pxNewQueue->u.xSemaphore.xMutexHolder = NULL; // 初始无持有者
    return pxNewQueue;
}

4.3 优先级继承实现

源码位置：xQueueGenericReceive()（在获取互斥量时触发）

// 当任务尝试获取互斥量但被阻塞时
if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
{
    // 检查当前持有者的优先级是否低于请求者
    if( pxQueue->u.xSemaphore.xMutexHolder != NULL )
    {
        if( pxCurrentTCB->uxPriority > pxQueue->u.xSemaphore.xMutexHolder->uxPriority )
        {
            // 临时提升持有者优先级
            vTaskPriorityInherit( pxQueue->u.xSemaphore.xMutexHolder, pxCurrentTCB->uxPriority );
        }
    }
}

---

5. 信号量的应用场景

5.1 任务同步

• 场景：任务 A 完成任务后通知任务 B。

SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary();

// 任务 A
void vTaskA( void *pvParameters )
{
    // 完成工作后释放信号量
    xSemaphoreGive( xSemaphore );
}

// 任务 B
void vTaskB( void *pvParameters )
{
    // 等待信号量
    xSemaphoreTake( xSemaphore, portMAX_DELAY );
    // 执行后续操作
}

5.2 资源管理（计数信号量）

• 场景：管理共享资源池（如内存块、外设）。

// 创建最大 5 个资源的计数信号量
SemaphoreHandle_t xResourceSem = xSemaphoreCreateCounting( 5, 5 );

// 任务获取资源
xSemaphoreTake( xResourceSem, portMAX_DELAY );
use_resource();
xSemaphoreGive( xResourceSem );

5.3 互斥量保护共享资源

• 场景：保护共享数据结构（如全局变量、硬件寄存器）。

SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

// 任务访问共享资源
xSemaphoreTake( xMutex, portMAX_DELAY );
critical_section();
xSemaphoreGive( xMutex );

5.4 中断与任务同步

• 场景：中断触发任务处理。

// 中断服务程序
void ADC_ISR( void )
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR( xADCSemaphore, &xHigherPriorityTaskWoken );
    portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

// 任务处理数据
void vADCTask( void *pvParameters )
{
    while(1)
    {
        xSemaphoreTake( xADCSemaphore, portMAX_DELAY );
        process_adc_data();
    }
}

---

6. 源码级调试技巧

1. 观察互斥量持有者：

   Queue_t *pxMutex = (Queue_t *)xMutex;
   TaskHandle_t xHolder = pxMutex->u.xSemaphore.xMutexHolder; // 当前持有任务
   

2. 查看信号量队列状态：

   UBaseType_t uxCount = uxQueueMessagesWaiting( xSemaphore ); // 当前可用信号量数量
   

---

7. 性能优化与注意事项

1. 优先使用二值信号量：比计数信号量更轻量。
2. 避免优先级反转：使用互斥量时确保优先级继承生效。
3. 静态内存分配：

   StaticSemaphore_t xSemaphoreBuffer;
   SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinaryStatic( &xSemaphoreBuffer );
   

4. 递归互斥量：用于同一任务多次获取锁的场景。

   xSemaphoreTakeRecursive( xMutex, portMAX_DELAY );
   xSemaphoreGiveRecursive( xMutex );
   

---

总结

FreeRTOS 信号量的实现本质是 队列的特化：

• 二值信号量：长度为 1 的队列，用于任务同步。
• 计数信号量：长度为 N 的队列，用于资源池管理。
• 互斥量：队列 + 优先级继承，解决资源竞争和优先级反转。

关键设计思想：

• 复用队列机制：通过数据大小为 0 的队列实现轻量级同步。
• 优先级继承：提升系统实时性，避免优先级反转问题。
• 类型区分：通过 ucQueueType 字段区分队列用途（普通队列、信号量、互斥量）。

理解信号量的队列本质后，可以灵活选择同步机制，并在资源受限的嵌入式系统中高效管理任务协作。