Free RTOS学习笔记 - 队列，信号量，互斥量，事件组，任务通知

坚持不懈z

已于 2023-12-14 09:56:23 修改

阅读量507

点赞数

CC 4.0 BY-SA版权

文章标签：学习笔记

于 2023-12-08 11:21:49 首次发布

本文链接：https://blog.youkuaiyun.com/zfh_persistence/article/details/134872049

本文介绍了FreeRTOS中的队列、信号量、互斥量、事件组和任务通知。队列采用先进先出操作，有创建、读写等操作；信号量只传递状态；互斥量解决优先级继承问题；事件组用整数位表示事件；任务通知有简化版和专业版，各有特点和函数原型。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、队列

1、队列的特点

数据的操作采用先进先出的方法（FIFO），写数据时放到尾部，读数据时从头部开始读取。

也可以强制写队列头部，但不会覆盖头部数据。

队列中每个数据的大小时固定的。

创建队列时要指定长度，数据大小。

2、队列的使用

在创建队列时，会创建两个链表，分别存放等待数据的任务和等待向队列中写的数据，buf中存放队列的数据。

1）创建队列

#define xQueueCreate( uxQueueLength, uxItemSize )    xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )
//uxQueueLength 队列长度
//uxItemSize 每个项大小

可以看到xQueueXCreat()最后调用的是xQueueGenericCreate()。

创建队列时，会创建几个指针，pcHead始终指向头部，不会移动；pcWriteto在初始化时指向头部，后面指向要写入的下一个位置；pcReadFrom指向上一次读的位置，使用前要指向这一次读的位置。

2）向队列中写入数据

//向队列中写数据
#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) \
    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
//向队列尾部写数据
#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) \
    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
//向队列首部写数据
#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) \
    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
//向队列尾部写数据，可以在中断函数中使用，不可阻塞
#define xQueueSendToBackFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
    xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
//向队列头部写数据，可以在中断函数中使用，不可阻塞
#define xQueueSendToFrontFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
    xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )

向队列中写数据，默认就是向队列尾部写数据；向队列头部写数据实际上是队列其他数据不变，然后写到pcReadFrom的位置，pcReadFrom向后移动一个位置，这样就写到了头部，下一次读取的就是这个数据。

3）从队列中读数据

BaseType_t xQueueReceive( QueueHandle_t xQueue,
                          void * const pvBuffer,
                          TickType_t xTicksToWait )
BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
                                 void * const pvBuffer,
                                 BaseType_t * const pxHigherPriorityTaskWoken )

4）查询

查询队列中有多少个数据，有多少剩余空间。

//返回队列中可用数据的个数
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue )
//返回队列中可用空间的个数
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue )

5）覆盖/偷看

当队列长度为1时，可以使用xQueueOverwrite()或xQueueOverwriteFromISR()来覆盖数据。队列长度必须为1，当队列满时，这些函数会覆盖里面的数据，这也意味着这些函数不会被阻塞。

#define xQueueOverwrite( xQueue, pvItemToQueue ) \
    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), 0, queueOVERWRITE )

#define xQueueOverwriteFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
    xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueOVERWRITE )

偷看时不会移除数据，这些函数会从队列中复制出数据。这样意味着如果队列中没有数据，这些函数将会一直阻塞，一旦队列中有数据，每次偷看都会成功。

BaseType_t xQueuePeek( QueueHandle_t xQueue,
                       void * const pvBuffer,
                       TickType_t xTicksToWait )

BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,
                              void * const pvBuffer )

3、队列集

顾名思义，队列集就是队列的集合，当接收程序想从多个队列中读取数据的时候，如果采用轮训的方式会导致效率低下，可以假设要从mouse，key，touch，三个队列中读取数据，当三个队列中某个队列由数据写入的时候，就会将其句柄放入到Queue_Set中，当从队列集中读取数据的时候，只需获取到其句柄，然后从其对应的队列中读取数据即可。

使用队列集的步骤如下：

	//1.创建队列集
	xQueueSet  = xQueueCreateSet(4);
	//2.添加联系
	xQueueAddToSet(xQueueHandle1,xQueueSet);
	xQueueAddToSet(xQueueHandle2,xQueueSet);
	//3.创建三个任务
	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, &xHandleTask1);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);
	xTaskCreate(Task3Function, "Task3", 100, NULL, 1, NULL);
    //4.读取QueueSet
    handle = xQueueSelectFromSet(xQueueSet,portMAX_DELAY)
    //5.读取队列
    xQueueReceive(handle,&i,0);

二、信号量

1、特点

只传递状态，不传递具体的信息。

相较于队列，更节省内存。

2、信号量和队列的区别，信号量的分类如下

二进制信号量	技术型信号量
被创建时初始值为0	被创建时初始值可以设定
其他操作一样	其它操作一样

3、信号量函数

1）创建信号量

//动态创建一个二进制信号量，返回它的句柄，可以看到实际上创建了一个长度为1，无符号字符型的队列
#define xSemaphoreCreateBinary()    xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )

//静态创建一个二进制信号量，返回它的句柄，可以看到实际上创建了一个长度为1，无符号字符型的队列
#define xSemaphoreCreateBinaryStatic( pxStaticSemaphore )    xQueueGenericCreateStatic( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticSemaphore, queueQUEUE_TYPE_BINARY_SEMAPHORE )

//动态创建一个计数型信号量
//返回它的句柄，
//uxMaxCount：最大计数值
//uxInitialCount ：计数初始值
 #define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount )    xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )

//静态创建一个技术型信号量
//返回它的句柄，非NULL代表成功
//uxMaxCount：最大计数值
//uxInitialCount：计数初始值
//pxSemaphoreBuffer ：StaticSemaphore_t结构体指针
#define xSemaphoreCreateCountingStatic( uxMaxCount, uxInitialCount, pxSemaphoreBuffer )    xQueueCreateCountingSemaphoreStatic( ( uxMaxCount ), ( uxInitialCount ), ( pxSemaphoreBuffer ) )

2）删除

//删除一个信号量
//xSemaphore ：信号量句柄
//实际上删除一个队列
#define vSemaphoreDelete( xSemaphore )  vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )

3）give/take

	在任务中使用	在ISR中使用
give	xSemaphoreGive	xSemaphoreGiveFromISR
take	xSemaphoreTake	xSemaphoreTakeFromISR

//释放信号量
//xSemaphore：释放哪个信号量
//返回值：pdTRUE，如果二进制信号量的计数值是1，再次调用则返回失败
                 如果计数型信号量的计数值已是最大值，再次调用则返回失败
#define xSemaphoreGive( xSemaphore )    xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

//在ISR中释放信号量
//xSemaphore：信号量句柄，释放哪个信号量
//pxHigherPriorityTaskWoken ：如果释放信号量导致更高优先级的任务变为了就绪态，则*pxHigherPriorityTaskWoken = pdTRUE
//返回值 pdTRUE表示成功，如果二进制信号量的计数值是1，再次调用则返回失败
                 如果计数型信号量的计数值已是最大值，再次调用则返回失败
#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )    xQueueGiveFromISR( ( QueueHandle_t ) ( xSemaphore ), ( pxHigherPriorityTaskWoken ) )

//拿走信号量
//xSemaphore：拿走哪个信号量
//xBlockTime：等待时间，0：不阻塞，马上返回portMAX_DELAY：一直阻塞到成功
//其他值，阻塞的Tick个数，可以使用pdMS_TO_TICKS()来指定阻塞时间为若干ms
//返回值，pdTRUE表示成功
#define xSemaphoreTake( xSemaphore, xBlockTime )    xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )

//在ISR中拿走信号量
//xSemaphore：信号量句柄，拿走哪个信号量
//pxHigherPriorityTaskWoken 如果获取信号量导致更高优先级的任务变为了就绪态，
则*pxHigherPriorityTaskWoken = pdTRUE
//返回值：返回pdTRTUE代表成功
#define xSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken )    xQueueReceiveFromISR( ( QueueHandle_t ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ) )

三、互斥量（互斥锁）

1、互斥量主要来解决两个问题：

信号量导致的优先级继承：假设一个场景，有三个信号量，A,B,C.优先级顺序是C>B>A，A执行后，A获得锁后执行，B到达就绪态，B执行，C到达就绪态，C执行，C想要获得锁，但是由于A拿走了锁，导致C阻塞，从而B执行，但是由于C阻塞，A的优先级小于B，所以B会一直执行。

优先级继承指的是，当C到达就绪态后，C想要获得锁，但是锁在A那里，往后，A获得C的优先级，A执行完后，释放锁，C继续执行。

谁拿走锁，谁释放锁。

但是FreeRTOS的一般的互斥量并没有实现这一点，而要靠递归锁实现。

2、函数原型

互斥量不能在ISR中使用，互斥量是一种特殊的信号量，获得和释放基本和信号量一致。

//动态创建一个互斥量，返它的句柄
//函数内部会分配一个互斥量的结构体
//返回值：返回句柄，非NULL表示成功
#define xSemaphoreCreateMutex()    xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )

//静态创建一个互斥量，返回它的句柄
//此函数无需动态分配内存，传入一个pxMutexBuffer 即可
//返回值：非NULL代表成功
#define xSemaphoreCreateMutexStatic( pxMutexBuffer )    xQueueCreateMutexStatic( queueQUEUE_TYPE_MUTEX, ( pxMutexBuffer ) )


//删除一个互斥量
//xSemaphore ：信号量的句柄结构体

//#define vSemaphoreDelete( xSemaphore )                   vQueueDelete( ( QueueHandle_t ) ( xSemaphore )

//释放互斥量
//xSemaphore：信号量的句柄结构体
#define xSemaphoreGive( xSemaphore )    xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

//获得互斥量
//xSemaphore：互斥量的句柄结构体
//xBlockTime ：等待时间
#define xSemaphoreTake( xSemaphore, xBlockTime )    xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )

3、递归锁

递归锁的函数和一般互斥量的函数名不一样，参数类型一样，列表如下

	递归锁	一般互斥量
创建	xSemaphoreCreateRecursiveMutex	xSemaphoreCreateMutex
获得	xSemaphoreTakeRecursive	xSemaphoreTake
释放	xSemaphoreGiveRecursive	xSemaphoreGive

函数原型

//创建一个递归锁
//返回值：返回句柄，非NULL代表成功
#define xSemaphoreCreateRecursiveMutex()    xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )

//释放互斥锁
//xMutex：递归锁句柄
//返回值：成功返回pdTRUE
#define xSemaphoreGiveRecursive( xMutex )    xQueueGiveMutexRecursive( ( xMutex ) )

//获得互斥锁
//xMutex：互斥锁句柄结构体
//xBlockTime：等待时间
//返回值：成功返回pdTRUE，超过xBlockTime时间，返回pdFALSE
#define xSemaphoreTakeRecursive( xMutex, xBlockTime )    xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )

四、事件组

1、特点

1）事件组可以认为是一个整数，每一位表示一个事件，每一位事件的含义由程序员决定，

2）一个或多个任务，ISR都可以去写这些位，一个或多个任务，ISR都可以去读这些位

3）可以等待某一位，某些位中的任意一个，也可以等待多位

4）能表示事件组的整数是多少位的，取决于系统是多少位的。

5）和队列和信号量的对比如下

队列、信号量	事件组
事件发生时，只会唤醒一个任务	时间发生时们可以唤醒所有符合条件的任务
是消耗型的资源，队列数据读走就没了，信号量获取后就减少了	被唤醒的任务有两个选择，可以让事件保持不动，也可以清除事件

2、函数原型

//静态创建一个事件组
//成功返回它的句柄结构体
EventGroupHandle_t xEventGroupCreate( void );

//动态创建一个事件组
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer );

//删除事件组
//xEventGroup:要删除事件组的句柄结构体
void vEventGroupDelete( EventGroupHandle_t xEventGroup );

//设置事件组中的位
//xEventGroup:事件组的句柄结构体
//uxBitsToSet:设置哪些位
//返回值：返回原来的事件值，意义不大
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                                const EventBits_t uxBitsToSet );

//在ISR中设置事件组的位
//pxHigherPriorityTaskWoken:有没有导致更高优先级的任务进入就绪态，pdTRUE-有，pdFALSE-没有
//返回值，paTRUE-成功，pdFALSE失败
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
                                          const EventBits_t uxBitsToSet,
                                          BaseType_t * pxHigherPriorityTaskWoken )
//等待事件
//uxBitsToWaitFor：等待哪些位，哪些位要被测试
//xClearOnExit：函数退出前是否要清除事件，pdTRUE,清除uxBitsToWaitFor的位，pdFALSE，不清除
//xClearOnExit：怎么测试，是AND还是OR，pdTRUE，等待的位全为1，pdFALSE，等待的位某一个为1
//xTicksToWait ：等待多久
//返回值：返回的是事件，即如果期待的时间发生了，则返回发生的事件。如果超时退出，则返回超时时刻的事件值
EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
                                 const EventBits_t uxBitsToWaitFor,
                                 const BaseType_t xClearOnExit,
                                 const BaseType_t xWaitForAllBits,
                                 TickType_t xTicksToWait )

3、同步点

假设有一个事情需要多个任务协同。

任务A：炒菜

任务B：买酒

任务C：摆台

ABC做好自己的任务后，还需等待别人做完才可以开饭

这个时候用同步点会更加方便

函数原型如下：

//xEventGroup：哪个事件组
//uxBitsToSet：自己完成了哪些事件
//uxBitsToWaitFor：要等待哪些事件
//xTicksToWait：等待多久
//返回值：如果期待的事件发生了，返回的是“非阻塞条件成立”时事件值
//如果超时退出，返回的是超时时刻的事件值
EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
                             const EventBits_t uxBitsToSet,
                             const EventBits_t uxBitsToWaitFor,
                             TickType_t xTicksToWait )

五、任务通知

1、任务通知的优点和缺点如下

优点	缺点
效率更高	不能发送数据给ISR
更节省内存，不需要创建额外的结构体	数据只能给该任务独享
	无法缓冲数据
	无法广播给多个任务
	如果发送受阻，发送方无法进入阻塞状态等待

任务通知中，值和状态保存在这里。

//configTASK_NOTIFICATION_ARRAY_ENTRIES 是1   
// ucNotifyState：taskNOT_WAITING_NOTIFICATION：任务没有在等待通知
//taskWAITING_NOTIFICATION：任务在等待通知
//taskNOTIFICATION_RECEIVED：任务接受到了通知
//通知值也有很多类型：计数值，位（类似事件组），任意数值
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
        volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
        volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    #endif

也就是说一个uint32_t类型，用来表示通知值，一个uint8_t 类型，用来表示状态。

2、函数原型

有两套，一套专业版，一套简化版

简化版：

使用xTaskNotifyGive()时：

使得通知值加1，并使得通知状态变为“pending”。

使用ulTaskNotifyTake()取出通知值时:

如果通知值等于0，则阻塞

当通知值大于0时。任务从阻塞态进入就绪态

在ulTaskNotifyTake()返回前，还可以做些清理工作，如把通知值减一，或者把通知值清零。


//xTaskToNotify：任务句柄，创建任务时得到，
//返回值：必定返回pdPASS 
#define xTaskNotifyGive( xTaskToNotify ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( 0 ), eIncrement, NULL )

#define vTaskNotifyGiveFromISR( xTaskToNotify, pxHigherPriorityTaskWoken ) \
    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( pxHigherPriorityTaskWoken ) );

//xClearCountOnExit:退出前是否清零，pdTRUE：把通知值清零，pdFALSE：不把通知值清零
//xTicksToWait:等待时间
//返回值：函数返回之前，在清零或减一之前的通知值
//如果xTicksToWait非零，则返回值有两种情况 大于0,：在超时前，通知值被增加了，等于0，一直没有其他任 
 //务增加通知值，最后超时返回。
#define ulTaskNotifyTake( xClearCountOnExit, xTicksToWait ) \
    ulTaskGenericNotifyTake( ( tskDEFAULT_INDEX_TO_NOTIFY ), ( xClearCountOnExit ), ( xTicksToWait ) )

专业版：

使用xTaskNotify()，可以设置参数，实现不同的功能。

1）让接收任务的通知值加1,：这时xTaskNotify()等同于xTaskNotifyGive()。

2）设置接收任务通知的某一位，某些位，这就是一个轻量级的更高效的事件组。

3）把一个新值写入接收任务的通知值：上一次被读走后写入才成功。这就是轻量级的，长度为1的队列。

4）用一个新值覆盖接收任务的通知值：无论上一次的通知值是否被读走，覆盖都成功。

xTaskNotifyWait()，

1）可以让任务等待（可以加上超时时间），等到任务状态为pending

2）可以在函数进入，退出时，清除通知值的指定位。

函数原型如下：

BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue,
eNotifyAction eAction );
BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify,
uint32_t ulValue,eNotifyAction eAction,
BaseType_t *pxHigherPriorityTaskWoken );
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,uint32_t ulBitsToClearOnExit,
uint32_t *pulNotificationValue,TickType_t xTicksToWait );

参数说明如下：

xTaskNotify()

xTaskToNotify	任务句柄
ulValue	如何使用，有eAction决定
eAction	见下表
返回值	paPASS：大部分都会成功 pdFAIL：只有一种情况会失败，当eAction为eSetValueWithoutOverwrite，并且通知状态为pending时，失败

eAction参数说明

eNoAction	仅仅是更新通知状态为“pending”，未使用value，这个相当于轻量级、更高效的二进制信号量
eSetBits	通知值 = 原来的通知值 \| ulValue，按位或相当于轻量级的、更高效的事件组
eIncrement	通知值 = 原来的通知值 + 1，未使用ulValue 相当于轻量级的、更高效的二进制信号量、技术型信号量
eSetValueWithoutOverwrite	不覆盖。如果通知状态为"pending"(表示有数据未读)，则此次调用xTaskNotify不做任何事，返回pdFAIL。如果通知状态不是"pending"(表示没有新数据)，则：通知值 = ulValue。
eSetValueWithOverwrite	覆盖，无论如何，不管通知状态是否为“pending”，通知值为value

xTaskNotifyWait()

ulBitsToClearOnEntry	在xTaskNotifyWait()入口处，要清除通知值的哪些位？通知状态不是“pending”的情况下，才会清除。它的本意是：我想等待某些事件的发生，所以先把“旧数据”的某些位清零能清零的话，通知值 = 通知值 & ~（ulBitsToClearOnEntry）比如传入0x01，表示清除通知值的bit0，传入0xffffffff，表示清除所有值
ulBitsToClearOnExit	在xTaskNotifyWait()出口处，如果不是因为超时退出，而是因为得到了数据退出：通知值 = 通知值 & ~(ulBitsToClearOnExit) 在清除某些位之前，通知值先被赋给*pulNotificationValue 比如传入0x03，表示清除通知值的bit0，bit1 传入0xffffffff，表示清除所有位，即把值设置为0
pulNotificationValue	用来取出通知值。在函数退出时，使用ulBitsToClearOnExit清除之前，把通知值赋给*pulNotificationValue 如果不需要取出通知值，可设为NULL
xTicksToWait	等待时间
返回值	pdPASS：表示xTaskNotifyWait()成功获得了通知，可能是在调用函数之前，通知状态变为了“pending” 也可能是在阻塞期间，通知状态变为了“pending” pdFAIL：没有得到通知

任务通知和队列的区别如下：

任务通知	队列
只有一个数据，数据是32位的	可以容纳多个数据，数据大小可以指定
写队列时，不可以阻塞	写队列时，可以阻塞
可以覆盖，也可以不覆盖	如果队列长度是1，可以选择覆盖队列

任务通知不能真正意义上实现事件组，因为

它不能等待指定的事件

它不能等待若干个事件中的任意一个

一旦有事件，总会唤醒任务

总结

内核对象	生产者	消费者	数据/状态	说明
队列	ALL	ALL	数据：若干个数据谁都可以向队列里扔数据谁都可以从队列中读取数据	用来传递数据发送者、接受者无限制，一个数据只能唤醒一个接收者
信号量	ALL	ALL	数量：0-n 谁都可以增加一个数量谁都可以消耗一个数量	用来维持资源的个数，生产者、消费者无限制。1个资源只能唤醒1个接收者
互斥量	只能A开锁	A上锁	位：0、1 我上锁：1变为0 只能由我开锁：0变为1	就向一个空厕所，谁使用谁上锁，也只能由他开锁
事件组	ALL	ALL	多个位：或、与谁都可以设置（生产）多个位，谁都可以等待某个位、若干个位	用来传递事件，发送者接收者无限制可以唤醒多个接收者
任务通知	ALL	只有我	数据、状态都可以传输使用任务通知时，必须指定接收者	N对1的关系，发送者无限制接受者只能是这个任务