FreeRTOS信号量（semaphore）

sakabu

已于 2024-08-10 21:23:23 修改

阅读量581

点赞数 19

分类专栏： FreeRTOS 文章标签： freeRTOS 学习笔记 c语言

于 2024-08-10 19:23:36 首次发布

本文链接：https://blog.csdn.net/sakabu/article/details/141073184

版权

FreeRTOS 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

前言

前面介绍的队列(queue)可以用于传输数据：在任务之间、任务和中断之间。

有时候我们只需要传递状态，并不需要传递具体的信息，比如：
         $\bullet$ 我的事做完了，通知一下你
         $\bullet$ 卖包子了、卖包子了，做好了1个包子！做好了2个包子！做好了3个包子！
         $\bullet$ 这个停车位我占了，你们只能等着

在这种情况下我们可以使用信号量(semaphore)，它更节省内存。

一、信号量概述

1.什么是信号量

信号量（Semaphore），是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代码段不被并发调用。

信号量这个名字，我们可以把它拆分来看，信号可以起到通知信号的作用，然后我们的量还可以用来表示资源的数量，当我们的量只有0和1的时候，它就可以被称作二值信号量，只有两个状态，当我们的那个量没有限制的时候，它就可以被称作为计数型信号量。

信号量也是队列的一种。

既然量可以代表资源的数量，那么信号量就支持两种“动作”：
$\bullet$ "give"给出资源，计数值加1；"take"获得资源，计数值减1

信号量的"give"、"take"双方并不需要相同，可以用于生产者-消费者场合：
         $\bullet$ 生产者为任务A、B，消费者为任务C、D
         $\bullet$ 一开始信号量的计数值为0，如果任务C、D想获得信号量，会有两种结果：
                 $\circ$ 阻塞：买不到东西咱就等等吧，可以定个闹钟(超时时间)
                 $\circ$ 即刻返回失败：不等
         $\bullet$ 任务A、B可以生产资源，就是让信号量的计数值增加1，并且把等待这个资源的顾客唤醒
         $\bullet$ 唤醒谁？谁优先级高就唤醒谁，如果大家优先级一样就唤醒等待时间最长的人

二进制信号量跟计数型的唯一差别，就是计数值的最大值被限定为1。

2.信号量跟队列的对比

2.1为什么要使用信号量？

使用队列也可以实现同步，为什么还要使用信号量呢?

$\bullet$ 使用队列可以传递数据，数据的保存需要空间
$\bullet$ 使用信号量时不需要传递数据，更节省空间
$\bullet$ 使用信号量时不需要复制数据，效率更高

3.两种信号量的对比

信号量的计数值都有限制：限定了最大值。如果最大值被限定为1，那么它就是二进制信号量；如果最大值不是1，它就是计数型信号量。

二、信号量函数

使用信号量时，先创建、然后去添加资源、获得资源。使用句柄来表示一个信号量。

1.创建

使用信号量之前，要先创建，得到一个句柄；使用信号量时，要使用句柄来表明使用哪个信号量。对于二进制信号量、计数型信号量，它们的创建函数不一样：

二值信号量创建后初始值为0。

创建二进制信号量的函数原型如下：

/* 创建一个二进制信号量，返回它的句柄。
* 此函数内部会分配信号量结构体
* 返回值: 返回句柄，非NULL表示成功
*/
SemaphoreHandle_t xSemaphoreCreateBinary( void );

/* 创建一个二进制信号量，返回它的句柄。
* 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
* 返回值: 返回句柄，非NULL表示成功
*/
SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t
*pxSemaphoreBuffer );

创建计数型信号量的函数原型如下：

/* 创建一个计数型信号量，返回它的句柄。
* 此函数内部会分配信号量结构体
* uxMaxCount: 最大计数值
* uxInitialCount: 初始计数值
* 返回值: 返回句柄，非NULL表示成功
*/
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t
uxInitialCount);

/* 创建一个计数型信号量，返回它的句柄。
* 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
* uxMaxCount: 最大计数值
* uxInitialCount: 初始计数值
* pxSemaphoreBuffer: StaticSemaphore_t结构体指针
* 返回值: 返回句柄，非NULL表示成功
*/
SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount,
UBaseType_t uxInitialCount,
StaticSemaphore_t
*pxSemaphoreBuffer );

2.删除

对于动态创建的信号量，不再需要它们时，可以删除它们以回收内存。

vSemaphoreDelete可以用来删除二进制信号量、计数型信号量，函数原型如下：

/*
* xSemaphore: 信号量句柄，你要删除哪个信号量
*/
void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );

3.give/take

二进制信号量、计数型信号量的give、take操作函数是一样的。这些函数也分为2个版本：给任务使用，给ISR使用。列表如下：

xSemaphoreGive的函数原型如下：

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore );

xSemaphoreGive函数的参数与返回值列表如下：

xSemaphoreTake的函数原型如下：

BaseType_t xSemaphoreTake(
    SemaphoreHandle_t xSemaphore,
    TickType_t xTicksToWait
);

xSemaphoreTake函数的参数与返回值列表如下：

三、使用二值信号量实现同步

main函数中创建了一个二进制信号量，然后创建2个任务：一个用于释放信号量，另一个用于获取信号量，代码如下：

/* 二进制信号量句柄 */
SemaphoreHandle_t xBinarySemaphore;
int main( void )
{
    prvSetupHardware();
    /* 创建二进制信号量 */
    xBinarySemaphore = xSemaphoreCreateBinary();
    if( xBinarySemaphore != NULL )
    {
        /* 创建1个任务用于释放信号量
        * 优先级为2
        */
        xTaskCreate( vSenderTask, "Sender", 1000, NULL, 2, NULL );
        /* 创建1个任务用于获取信号量
        * 优先级为1
        */
        xTaskCreate( vReceiverTask, "Receiver", 1000, NULL, 1, NULL );
        /* 启动调度器 */
        vTaskStartScheduler();
    }
    else
    {
        /* 无法创建二进制信号量 */
    }
    /* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
    return 0;
}

两个任务的函数如下：

运行结果如下：

发送任务、接收任务的代码和执行流程如下：

A：发送任务优先级高，先执行。连续3次释放二进制信号量，只有第1次成功
B：发送任务进入阻塞态
C：接收任务得以执行，得到信号量，打印OK；再次去获得信号量时，进入阻塞状态在发送任务的vTaskDelay退出之前，运行的是空闲任务：现在发送任务、接收任务都阻塞了
D：发送任务再次运行，连续3次释放二进制信号量，只有第1次成功
E：发送任务进入阻塞态
F：接收任务被唤醒，得到信号量，打印OK；再次去获得信号量时，进入阻塞状态

即使发送任务连续释放多个信号量，也只能成功1次。释放、获得信号量是一一对应的。

计数型信号量无非就是能设置初始值和上限值，用法和二值信号量一样，看什么场景什么适用，这个和我之前学的互斥量差不太多，也是拿锁和上锁，总的来说都是实现同步的功能，不能实现数据交换。

sakabu

关注

19
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
FreeRTOS信号量（semaphore）

前面介绍的队列(queue)可以用于传输数据：在任务之间、任务和中断之间。有时候我们只需要传递状态，并不需要传递具体的信息，比如：我的事做完了，通知一下你卖包子了、卖包子了，做好了1个包子！做好了2个包子！做好了3个包子！这个停车位我占了，你们只能等着在这种情况下我们可以使用信号量(semaphore)，它更节省内存。信号量（Semaphore），是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代码段不被并发调用。信号量这个名字，我们可以把它拆分来看，
复制链接

扫一扫