1. 知識點回顧

隊列（queue）是一種只能在一端插入元素、在另一端刪除元素的數據結構，遵循先入先出（FIFO）的規則。

環形隊列（ring queue）可以方便的重復利用這段內存空間，同樣遵循先入先出（FIFO）的規則。

優先級隊列（prio queue）不遵循FIFO，而是根據元素的優先級進行出隊，優先級最高的先出隊。

「本文的所有內容都是基于這兩個數據結構」，TencentOS-tiny中環形隊列和優先級隊列的實現和使用示例請閱讀文章：

數據結構 | TencentOS-tiny中隊列、環形隊列、優先級隊列的實現及使用

2. 消息隊列

2.1. 什么是消息隊列

消息隊列，Message Queue，顧名思義包含兩部分：消息+隊列，或者可以理解為消息的隊列。

① 消息是什么？

兩個不同的任務之間傳遞數據時，這個數據就稱之為消息，這個消息可以是一個整型值，浮點值，甚至一個結構體，一個指針……所以，在使用不同的RTOS的消息隊列時，「一定要注意傳遞的是值還是該值的地址」。

傳遞值的缺點是值的長度有大有小，導致整個消息隊列的長度有大有小。

一個指針的長度是固定的4字節，傳遞值的時候，無論值是什么類型，只傳遞該值的地址。

傳遞地址當然也有缺陷，當動態任務task1中定義了一個局部變量，然后把該局部變量的地址傳給了task2，隨即task1因為某種原因被銷毀，內存回收，導致指向該局部變量的指針變為野指針，非常危險，不過不用慌，小問題，在編程的時候注意避免即可。

「在TencentOS-tiny中，消息隊列中傳遞的消息指的是地址，郵箱隊列傳遞的消息是值」。

② 隊列是什么？

消息隊列如果底層使用環形隊列存儲消息，則成為消息隊列，遵循：先送入的消息先被取出。

消息隊列如果底層使用優先級隊列存儲消息，則成為優先級消息隊列，遵循：優先級最高的消息最先被取出。

「在TencentOS-tiny中，這兩種消息隊列都有，下面一一講述?！?/p>

③ pend-post機制

無論是什么隊列，都存在兩種情況：當隊列滿了的時候，元素再入隊會發生錯誤；當隊列為空的時候，元素出隊同樣會發生錯誤。

這種問題可以巧妙的在隊列基礎之上用pend-post機制解決，即等待-釋放機制。

當隊列「滿了」的時候，前來入隊的task1可以選擇pend一段時間或者永久等待，「一旦有元素被task2出隊」，調用post釋放一個信號，「喚醒等待中的task1」。

同樣，當隊列「空了」的時候，前來出隊的task1可以選擇pend一段時間或者永久等待，「一旦有元素被task2入隊」，調用post釋放一個信號，「喚醒等待中的task1」。

是不是很巧妙？

接下來上源碼！上Demo！一看便知~

2.2. 消息隊列的實現

TencentOS-tiny中消息隊列的實現在 tos_message_queue.h和tos_message_queue.c中。

typedef struct k_message_queue_st {

knl_obj_t knl_obj;

pend_obj_t pend_obj;

k_ring_q_t ring_q;

} k_msg_q_t;

一個pend_obj對象用來實現pend-post機制，一個ring_q環形隊列用來存儲消息。

是不是和我講述的沒錯？學透了之后，其實一切都沒有那么神秘的~

再來看看從消息隊列中獲取消息的API實現：

__API__ k_err_t tos_msg_q_pend（k_msg_q_t *msg_q， void **msg_ptr， k_tick_t timeout）

{

//省略了部分源碼

TOS_CPU_INT_DISABLE（）;

if （tos_ring_q_dequeue（&msg_q-》ring_q， msg_ptr， K_NULL） == K_ERR_NONE） {

TOS_CPU_INT_ENABLE（）;

return K_ERR_NONE;

}

pend_task_block（k_curr_task， &msg_q-》pend_obj， timeout）;

TOS_CPU_INT_ENABLE（）;

knl_sched（）;

return err;

}

向消息隊列中存放消息的API實現如下：

__STATIC__ k_err_t msg_q_do_post（k_msg_q_t *msg_q， void *msg_ptr， opt_post_t opt）

{

//省略了部分源碼

TOS_CPU_INT_DISABLE（）;

if （pend_is_nopending（&msg_q-》pend_obj）） {

err = tos_ring_q_enqueue（&msg_q-》ring_q， &msg_ptr， sizeof（void*））;

if （err ！= K_ERR_NONE） {

TOS_CPU_INT_ENABLE（）;

return err;

}

TOS_CPU_INT_ENABLE（）;

return K_ERR_NONE;

}

if （opt == OPT_POST_ONE） {

msg_q_task_recv（TOS_LIST_FIRST_ENTRY（&msg_q-》pend_obj.list， k_task_t， pend_list）， msg_ptr）;

} else { // OPT_POST_ALL

TOS_LIST_FOR_EACH_ENTRY_SAFE（task， tmp， k_task_t， pend_list， &msg_q-》pend_obj.list） {

msg_q_task_recv（task， msg_ptr）;

}

}

TOS_CPU_INT_ENABLE（）;

knl_sched（）;

return K_ERR_NONE;

}

從源碼中可以看到，如果opt標志為 OPT_POST_ONE，表示喚醒一個，則喚醒該消息隊列等待列表上任務優先級最高的那個；如果opt標志為 OPT_POST_ALL，則全部喚醒。

2.3. 消息隊列的使用示例

#define MESSAGE_MAX 10

uint8_t msg_pool［MESSAGE_MAX * sizeof（void *）］;

k_msg_q_t msg_q;

void entry_task_receiver（void *arg）

{

k_err_t err;

void *msg_received;

while （K_TRUE） {

err = tos_msg_q_pend（&msg_q， &msg_received， TOS_TIME_FOREVER）;

if （err == K_ERR_NONE） {

printf（“receiver： msg incoming［%s］

”， （char *）msg_received）;

}

}

}

void entry_task_sender（void *arg）

{

char *msg_prio_0 = “msg 0 without priority”;

char *msg_prio_1 = “msg 1 without priority”;

char *msg_prio_2 = “msg 2 without priority”;

printf（“sender： post a message 2 without priority

”）;

tos_msg_q_post（&msg_q， msg_prio_2）;

printf（“sender： post a message 1 without priority

”）;

tos_msg_q_post（&msg_q， msg_prio_1）;

printf（“sender： post a message 0 without priority

”）;

tos_msg_q_post（&msg_q， msg_prio_0）;

}

執行結果如下：

TencentOS-tiny Port on STM32L431RCT6 By Mculover666

sender： post a message 2 without priority

sender： post a message 1 without priority

sender： post a message 0 without priority

receiver： msg incoming［msg 2 without priority］

receiver： msg incoming［msg 1 without priority］

receiver： msg incoming［msg 0 without priority］

3. 優先級消息隊列3.1. 優先級消息隊列的實現

實現和消息隊列類似，通過在優先級隊列的基礎上加上pend-post機制來實現。

TencentOS-tiny中優先級消息隊列的實現在tos_priority_message_queue.h和tos_priority_message_queue.c中。

typedef struct k_priority_message_queue_st {

knl_obj_t knl_obj;

pend_obj_t pend_obj;

void *prio_q_mgr_array;

k_prio_q_t prio_q;

} k_prio_msg_q_t;

其中pend_obj用于掛載等待該優先級消息隊列的任務，prio_q和prio_q_mgr_array合起來實現優先級隊列。

消息入隊和消息出隊的API實現與消息隊列的實現思想一模一樣，這里不再講解。

3.2. 優先級消息隊列的使用示例

#define MESSAGE_MAX 10

uint8_t msg_pool［MESSAGE_MAX * sizeof（void *）］;

k_prio_msg_q_t prio_msg_q;

void entry_task_receiver（void *arg）

{

k_err_t err;

void *msg_received;

while （K_TRUE） {

err = tos_prio_msg_q_pend（&prio_msg_q， &msg_received， TOS_TIME_FOREVER）;

if （err == K_ERR_NONE） {

printf（“receiver： msg incoming［%s］

”， （char *）msg_received）;

}

}

}

void entry_task_sender（void *arg）

{

char *msg_prio_0 = “msg with priority 0”;

char *msg_prio_1 = “msg with priority 1”;

char *msg_prio_2 = “msg with priority 2”;

printf（“sender： post a message with priority 2

”）;

tos_prio_msg_q_post（&prio_msg_q， msg_prio_2， 2）;

printf（“sender： post a message with priority 1

”）;

tos_prio_msg_q_post（&prio_msg_q， msg_prio_1， 1）;

printf（“sender： post a message with priority 0

”）;

tos_prio_msg_q_post（&prio_msg_q， msg_prio_0， 0）;

}

運行結果如下：

TencentOS-tiny Port on STM32L431RCT6 By Mculover666

sender： post a message with priority 2

sender： post a message with priority 1

sender： post a message with priority 0

receiver： msg incoming［msg with priority 0］

receiver： msg incoming［msg with priority 1］

receiver： msg incoming［msg with priority 2］

?

將第2節的結果和第3節的結果對比，就會發現同樣的消息發送順序，因為使用不同的消息隊列，任務獲取到的消息順序截然不同。

4. 郵箱隊列

4.1. 不同之處

消息隊列和郵箱隊列的不同之處，在于底層隊列每個元素類型不一樣，看一眼源碼便知。

消息隊列傳遞的消息是地址，所以在初始化消息隊列的時候，環形隊列中每個元素都是空指針類型：

__API__ k_err_t tos_msg_q_create（k_msg_q_t *msg_q， void *pool， size_t msg_cnt）

{

//部分源碼省略

//重點：隊列中每個元素類型大小是sizeof（void*）

err = tos_ring_q_create（&msg_q-》ring_q， pool， msg_cnt， sizeof（void *））;

if （err ！= K_ERR_NONE） {

return err;

}

return K_ERR_NONE;

}

而郵箱隊列傳遞的是值，所以在初始化底層用到的環形隊列時，每個元素的大小是由用戶指定的：

__API__ k_err_t tos_mail_q_create（k_mail_q_t *mail_q， void *pool， size_t mail_cnt， size_t mail_size）

{

//省略了部分源碼

//重點：每個元素的大小是mail_size，由用戶傳入參數指定

err = tos_ring_q_create（&mail_q-》ring_q， pool， mail_cnt， mail_size）;

if （err ！= K_ERR_NONE） {

return err;

}

return K_ERR_NONE;

}

4.2. 郵箱隊列的實現

這有什么好實現的~一個環形隊列+pend-post對象即可。

TencentOS-tiny中郵箱隊列的實現在tos_mail_queue.h和tos_mail_queue.c中。

typedef struct k_mail_queue_st {

knl_obj_t knl_obj;

pend_obj_t pend_obj;

k_ring_q_t ring_q;

} k_mail_q_t;

是不是沒什么區別~至于操作的API，更沒啥區別，不寫了，劃水劃水。

4.3. 郵箱隊列的使用示例

#define MAIL_MAX 10

typedef struct mail_st {

char *message;

int payload;

} mail_t;

uint8_t mail_pool［MAIL_MAX * sizeof（mail_t）］;

k_mail_q_t mail_q;

void entry_task_receiver_higher_prio（void *arg）

{

k_err_t err;

mail_t mail;

size_t mail_size;

while （K_TRUE） {

err = tos_mail_q_pend（&mail_q， &mail， &mail_size， TOS_TIME_FOREVER）;

if （err == K_ERR_NONE） {

TOS_ASSERT（mail_size == sizeof（mail_t））;

printf（“higher： msg incoming［%s］， payload［%d］

”， mail.message， mail.payload）;

}

}

}

void entry_task_receiver_lower_prio（void *arg）

{

k_err_t err;

mail_t mail;

size_t mail_size;

while （K_TRUE） {

err = tos_mail_q_pend（&mail_q， &mail， &mail_size， TOS_TIME_FOREVER）;

if （err == K_ERR_NONE） {

TOS_ASSERT（mail_size == sizeof（mail_t））;

printf（“lower： msg incoming［%s］， payload［%d］

”， mail.message， mail.payload）;

}

}

}

void entry_task_sender（void *arg）

{

int i = 1;

mail_t mail;

while （K_TRUE） {

if （i == 2） {

printf（“sender： send a mail to one receiver， and shoud be the highest priority one

”）;

mail.message = “1st time post”;

mail.payload = 1;

tos_mail_q_post（&mail_q， &mail， sizeof（mail_t））;

}

if （i == 3） {

printf（“sender： send a message to all recevier

”）;

mail.message = “2nd time post”;

mail.payload = 2;

tos_mail_q_post_all（&mail_q， &mail， sizeof（mail_t））;

}

if （i == 4） {

printf（“sender： send a message to one receiver， and shoud be the highest priority one

”）;

mail.message = “3rd time post”;

mail.payload = 3;

tos_mail_q_post（&mail_q， &mail， sizeof（mail_t））;

}

if （i == 5） {

printf（“sender： send a message to all recevier

”）;

mail.message = “4th time post”;

mail.payload = 4;

tos_mail_q_post_all（&mail_q， &mail， sizeof（mail_t））;

}

tos_task_delay（1000）;

++i;

}

}

運行結果為：

TencentOS-tiny Port on STM32L431RCT6 By Mculover666

sender： send a mail to one receiver， and shoud be the highest priority one

higher： msg incoming［1st time post］， payload［1］

sender： send a message to all recevier

higher： msg incoming［2nd time post］， payload［2］

lower： msg incoming［2nd time post］， payload［2］

sender： send a message to one receiver， and shoud be the highest priority one

higher： msg incoming［3rd time post］， payload［3］

sender： send a message to all recevier

higher： msg incoming［4th time post］， payload［4］

lower： msg incoming［4th time post］， payload［4］

此示例主要演示了兩點：1. 如何使用郵箱隊列直接傳遞值；2. 喚醒一個等待任務和喚醒所有等待任務的區別。

5. 優先級郵箱隊列

看到這里，這個不能再講了吧~

TencentOS-tiny中實現在tos_priority_mail_queue.c 和tos_priority_mail_queue.h中。

可以自己嘗試根據前面的demo，編寫出一個使用優先級郵箱隊列的demo，測試高優先級的郵件是否會被先收到，然后將結果與第4節的實驗結果進行對比。

越到文末我越浪，劃水已經不能滿足了，博主要去摸魚~

6. 總結

按照慣例，對本文所講的內容進行一個總結。

本文主要講述了用于任務間通信的一些內核對象，主要有四個：消息隊列和優先級消息隊列，郵箱隊列和優先級郵箱隊列。

接下來列出一些重要的點：

① 「在使用RTOS中的一些用于任務間通信的量時，要注意傳遞的是值還是地址。TencentOS-tiny中消息隊列傳輸的是地址，而郵箱隊列傳遞的是值。」

② 「消息隊列和郵箱隊列基于環形隊列實現，遵循FIFO規則；而優先級消息隊列和優先級郵箱隊列基于優先級隊列實現，遵循按照元素優先級取出的規則?！?/p>

最后來回答題目中的問題：任務間通信為什么不使用全局變量？

① 無論是消息隊列還是郵箱隊列，都是利用了全局變量可以被隨意訪問的特性，所以使用時都會被定義為全局變量。

② 普通全局變量可用于一些簡單的任務間通信場合。

③ 相較于普通全局變量，加入隊列機制可以存儲多個消息，加入pend-post機制可以擁有任務等待和喚醒的機制，用于解決隊列已滿或隊列為空的問題。
編輯：lyn