FreeRTOS 任务通知源码剖析:凭什么比二值信号量快 45%?

/* FreeRTOS/tasks.c（TCB_t 内的 xNOTIFICATION 结构成员） */#if ( configUSE_TASK_NOTIFICATIONS == 1 )    volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];  /* 32 位通知值 */    volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];      /* 通知状态 */#endif

/* 示例：通道号宏约定 */#define CH_KEY        0    /* 约定：按键事件走通道 0 */#define CH_ADC_DONE   1    /* 约定：ADC 完成走通道 1 *//* 发送方（如 ADC 转换完成中断里） */xTaskNotifyIndexed(xTaskH, CH_ADC_DONE, 0, eNoAction);/* 接收方 */ulTaskNotifyTakeIndexed(CH_ADC_DONE, pdTRUE, portMAX_DELAY);

#include"FreeRTOS.h"#include"task.h"/* xTaskNotifyGive / ulTaskNotifyTake 都在 task.h */#include<stdio.h>/* 实验参数。注意本工程 configTICK_RATE_HZ=100，1 tick=10ms：*//* pdMS_TO_TICKS(<10) 会被取整为 0——所有延时参数都必须 ≥10ms */#define NTf_BINARY_ROUNDS      5       /* 实验一：每秒发 1 次，共 5 次 */#define NTf_BINARY_PERIOD_MS   1000#define NTf_COUNT_ROUNDS       3       /* 实验二：每轮连发 3 次，共 3 轮 */#define NTf_COUNT_PERIOD_MS    2000/* printf 任务栈：标准库 printf 栈开销大，128 字容易触发栈溢出钩子，统一给 256 字 */#define NTf_PRINTF_STACK       ( configMINIMAL_STACK_SIZE * 2 )/* 接收任务句柄：xTaskNotifyGive 是"点对点"API，*/ /* 发送方必须先拿到目标句柄——创建任务时用 xTaskCreate 第 6 个参数保存 */static TaskHandle_t xNotifyReceiverHandle = NULL;

staticvoidvNotifySender(void *pvParameters){    (void)pvParameters;    uint32_t i, j;    for (;;)    {        /* ---- 实验一：每秒 xTaskNotifyGive 一次，*/         /*      相当于 xSemaphoreGive(二值信号量)，但不需要创建任何内核对象 ---- */        for (i = 1; i <= NTf_BINARY_ROUNDS; i++)        {            vTaskDelay(pdMS_TO_TICKS(NTf_BINARY_PERIOD_MS));            printf("任务A：xTaskNotifyGive 发送通知（第 %u 次）\r\n", (unsigned int)i);            /* 宏展开为 xTaskGenericNotify(句柄, 0, 0, eIncrement, NULL)：通知值 +1 */            (void)xTaskNotifyGive(xNotifyReceiverHandle);            /* Give 把 B 搬进就绪链表（唤醒），但 A(+2) 优先级更高继续执行，*/             /* 直到循环回到 vTaskDelay 让出 CPU，B 才上 CPU、Take 才返回消费 */        }        /* ---- 实验二：快速连发 3 次，通知值累计到 3 不丢失，*/         /*      相当于计数信号量的多次 Give ---- */        for (i = 1; i <= NTf_COUNT_ROUNDS; i++)        {            vTaskDelay(pdMS_TO_TICKS(NTf_COUNT_PERIOD_MS));            printf("任务A：快速连发 3 次通知（第 %u 轮）\r\n", (unsigned int)i);            for (j = 0; j < 3; j++)            {                (void)xTaskNotifyGive(xNotifyReceiverHandle);            }            /* 本任务优先级更高，连发期间接收方不会抢占——3 次通知先攒进它的 TCB */        }        /* 一轮共 5s + 6s = 11s，回到实验一重新开始 */    }}

staticvoidvNotifyReceiver(void *pvParameters){    (void)pvParameters;    uint32_t i, j, ulValue;    for (;;)    {        /* ---- 实验一：二值语义——xClearCountOnExit=pdTRUE，取走后通知值清零 ---- */        printf("\r\n=== 实验一：任务通知替代二值信号量（ulTaskNotifyTake 清零模式）===\r\n");        for (i = 1; i <= NTf_BINARY_ROUNDS; i++)        {            /* 通知值==0 时阻塞；被唤醒（或等待前通知已到）后返回并清零通知值 */            (void)ulTaskNotifyTake(pdTRUE, portMAX_DELAY);            printf("任务B：收到通知，通知值已清零（二值语义，第 %u 次）\r\n", (unsigned int)i);        }        /* ---- 实验二：计数语义——xClearCountOnExit=pdFALSE，取走后通知值减 1 ---- */        printf("\r\n=== 实验二：任务通知替代计数信号量（ulTaskNotifyTake 递减模式）===\r\n");        for (i = 1; i <= NTf_COUNT_ROUNDS; i++)        {            for (j = 0; j < 3; j++)            {                /* 返回值是"清零/递减之前"的通知值：3 次连发后依次返回 3、2、1 */                ulValue = ulTaskNotifyTake(pdFALSE, portMAX_DELAY);                printf("任务B：取走 1 个通知，取走前计数值=%u，取走后剩余=%u\r\n",                       (unsigned int)ulValue, (unsigned int)(ulValue - 1u));            }        }        /* 回到实验一，循环往复 */    }}

voidtask_notify_demo(void){    /* 先创建接收方并保存句柄（创建发生在调度器启动前，句柄无竞态） */    xTaskCreate(vNotifyReceiver, "NtfRcv", NTf_PRINTF_STACK, NULL,                tskIDLE_PRIORITY + 1, &xNotifyReceiverHandle);    /* 发送方优先级更高（+2）：实验二连发 3 次期间接收方不会中途醒来消费 */    xTaskCreate(vNotifySender, "NtfSend", NTf_PRINTF_STACK, NULL,                tskIDLE_PRIORITY + 2, NULL);}

=== 实验一：任务通知替代二值信号量（ulTaskNotifyTake 清零模式）===任务A：xTaskNotifyGive 发送通知（第 1 次）任务B：收到通知，通知值已清零（二值语义，第 1 次）任务A：xTaskNotifyGive 发送通知（第 2 次）任务B：收到通知，通知值已清零（二值语义，第 2 次）...（每秒 1 对，共 5 对）=== 实验二：任务通知替代计数信号量（ulTaskNotifyTake 递减模式）===任务A：快速连发 3 次通知（第 1 轮）任务B：取走 1 个通知，取走前计数值=3，取走后剩余=2任务B：取走 1 个通知，取走前计数值=2，取走后剩余=1任务B：取走 1 个通知，取走前计数值=1，取走后剩余=0任务A：快速连发 3 次通知（第 2 轮）...（共 3 轮，随后回到实验一重新开始）

/* FreeRTOS/include/task.h */#define xTaskNotifyGive( xTaskToNotify ) \    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( 0 ), eIncrement, NULL )#define xTaskNotify( xTaskToNotify, ulValue, eAction ) \    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL )#define ulTaskNotifyTake( xClearCountOnExit, xTicksToWait ) \    ulTaskGenericNotifyTake( ( tskDEFAULT_INDEX_TO_NOTIFY ), ( xClearCountOnExit ), ( xTicksToWait ) )

/* FreeRTOS/tasks.c（节选） */taskENTER_CRITICAL();                                       /* 临界区保护整个"改值+唤醒" */{    ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ];    pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED;   /* 先置"有通知" */    switch( eAction )                                        /* 通知值按动作解读 */    {        case eSetBits:      /* 按位或：把 ulValue 中为 1 的位置起，原有位不动。 */                            /* "单任务版事件组"用它：多个事件源各占一位， */                            /* 接收端 xTaskNotifyWait 按位判断、按位清零 */            pxTCB->ulNotifiedValue[ uxIndexToNotify ] |= ulValue;            break;        case eIncrement:    /* 就是 ++，不看 ulValue 传了什么。 */                            /* xTaskNotifyGive 的底层动作：配 ulTaskNotifyTake */                            /* 就是二值/计数信号量语义（攒次数） */            ( pxTCB->ulNotifiedValue[ uxIndexToNotify ] )++;            break;        case eSetValueWithOverwrite:    /* 直接覆盖写：当"长度 1 的邮箱"用。 */                                        /* 风险：上一条没读走就被新值顶掉—— */                                        /* 适合"只要最新值"的场景（如最新采样） */            pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue;            break;        case eSetValueWithoutOverwrite:    /* 也是覆盖写，但先查状态： */                                           /* 没挂未读通知（状态!=RECEIVED—— */                                           /* 含"正在阻塞等待"的 WAITING）才写； */                                           /* 还挂着未读（RECEIVED）就拒绝，返回 pdFAIL。 */                                           /* 相当于"长度 1、满了不能放"的队列—— */                                           /* 要保证每条都被读到就用它 */            if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )            {                pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue;            }            else            {                xReturn = pdFAIL;                            /* 已有未读通知，拒绝覆盖 */            }            break;        case eNoAction:      /* 值一个字节都不碰，只置"有通知"状态。 */                             /* 纯事件语义：接收方只关心"来过没有"， */                             /* 不关心带没带数据——最省心的信号灯 */            break;        ...    }    /* 若目标正阻塞在通知上：从阻塞链表（延时/挂起链表）摘出、加入就绪链表（唤醒） */    if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )    {        listREMOVE_ITEM( &( pxTCB->xStateListItem ) );        prvAddTaskToReadyList( pxTCB );        /* 被唤醒任务优先级更高则立即让出（任务上下文可直接切换） */        taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxTCB );    }}taskEXIT_CRITICAL();

/* FreeRTOS/tasks.c（节选） */taskENTER_CRITICAL();{    /* 只在通知值为 0 时才需要阻塞——     * 若之前的通知还没被取走（值非 0），本次 Take 立即成功，通知绝不丢失 */    if( pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] == 0U )    {        pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] = taskWAITING_NOTIFICATION;        if( xTicksToWait > ( TickType_t ) 0 ) { xShouldBlock = pdTRUE; }    }}taskEXIT_CRITICAL();...   /* 阻塞：有限超时挂延时链表，portMAX_DELAY 挂挂起链表（见下方节选说明） */taskENTER_CRITICAL();{    ulReturn = pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ];   /* 返回"清零/递减之前"的值 */    if( ulReturn != 0U )    {        if( xClearCountOnExit != pdFALSE )        {            pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] = 0U;            /* 二值：清零 */        }        else        {            pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] = ulReturn - 1U; /* 计数：减 1 */        }    }    pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] = taskNOT_WAITING_NOTIFICATION;}taskEXIT_CRITICAL();

/* FreeRTOS/include/task.h（参数省略索引版） */BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,                            uint32_t ulBitsToClearOnExit,                            uint32_t *pulNotificationValue,                            TickType_t xTicksToWait );

/* FreeRTOS/tasks.c（节选） */portASSERT_IF_INTERRUPT_PRIORITY_INVALID();                  /* 中断优先级合法性断言 */uxSavedInterruptStatus = ( UBaseType_t ) taskENTER_CRITICAL_FROM_ISR();  /* ISR 专用临界区 */{    ...                                                      /* 改值逻辑与 4.1 完全一致 */    if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )    {        if( uxSchedulerSuspended == ( UBaseType_t ) 0U )        {            listREMOVE_ITEM( &( pxTCB->xStateListItem ) );            prvAddTaskToReadyList( pxTCB );        }        else        {            /* 调度器挂起期间：先挂到 xPendingReadyList，恢复后再入就绪 */            listINSERT_END( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );        }        if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )   /* 单核：唤醒了更高优先级任务 */        {            if( pxHigherPriorityTaskWoken != NULL )            {                *pxHigherPriorityTaskWoken = pdTRUE;         /* 只做标记，不切换！ */            }            xYieldPendings[ 0 ] = pdTRUE;        }    }}taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );

ISR 退出 → 硬件发现 PendSV 挂着 → PendSV 优先级最低，等所有嵌套中断都退出后才执行 → PendSV 里调 vTaskSwitchContext，扫就绪链表数组，挑最高优先级的任务上 CPU

BaseType_t xWoken = pdFALSE;xTaskNotifyFromISR(h, 0, eIncrement, &xWoken);portYIELD_FROM_ISR(xWoken);   /* 更高：立刻切；相等/更低：空转零代价 */

— 写在最后 —

如果这篇文章对你有帮助，欢迎点赞、在看、转发三连支持，这是我持续更新的最大动力。

有问题欢迎在评论区指出，我都会认真看。

点个关注不迷路，更多硬核技术剖析持续更新中，下期再见。