佇列Queue：任務間的訊息讀寫，安排起來~

摘要：本文通過分析鴻蒙輕核心佇列模組的原始碼，掌握佇列使用上的差異。

本文分享自華為雲社群《鴻蒙輕核心M核原始碼分析系列十三 訊息佇列Queue》，作者：zhushy 。

佇列（Queue）是一種常用於任務間通訊的資料結構。任務能夠從佇列裡面讀取訊息，當佇列中的訊息為空時，掛起讀取任務；當佇列中有新訊息時，掛起的讀取任務被喚醒並處理新訊息。任務也能夠往佇列裡寫入訊息，當佇列已經寫滿訊息時，掛起寫入任務；當佇列中有空閒訊息節點時，掛起的寫入任務被喚醒並寫入訊息。如果將讀佇列和寫佇列的超時時間設定為0，則不會掛起任務，介面會直接返回，這就是非阻塞模式。訊息佇列提供了非同步處理機制，允許將一個訊息放入佇列，但不立即處理。同時佇列還有緩衝訊息的作用。

本文通過分析鴻蒙輕核心佇列模組的原始碼，掌握佇列使用上的差異。本文中所涉及的原始碼，以OpenHarmony LiteOS-M核心為例，均可以在開源站點https://gitee.com/openharmony/kernel_liteos_m 獲取。

1、佇列結構體定義和常用巨集定義

1.1 佇列結構體定義

在檔案kernel\include\los_queue.h中定義佇列控制塊結構體為LosQueueCB，結構體原始碼如下。佇列狀態.queueState取值OS_QUEUE_UNUSED、OS_QUEUE_INUSED，其他結構體成員見註釋部分。

typedef struct {
    UINT8 *queue;      /**< 佇列記憶體空間的指標 */
    UINT16 queueState; /**< 佇列的使用狀態 */
    UINT16 queueLen;   /**< 佇列長度，即訊息數量 */
    UINT16 queueSize;  /**< 訊息節點大小 */
    UINT16 queueID;    /**< 佇列編號  */
    UINT16 queueHead;  /**< 訊息頭節點位置 */
    UINT16 queueTail;  /**< 訊息尾節點位置 */
    UINT16 readWriteableCnt[OS_READWRITE_LEN]; /**< 2維陣列，可讀、可寫的訊息數量, 0:可讀, 1:可寫 */
    LOS_DL_LIST readWriteList[OS_READWRITE_LEN]; /**< 2維雙向連結串列陣列，阻塞讀、寫任務的雙向連結串列, 0:讀連結串列, 1:寫連結串列 */
    LOS_DL_LIST memList; /**< 記憶體節點雙向連結串列 */
} LosQueueCB;

1.2 佇列常用巨集定義

系統支援建立多少佇列是根據開發板情況使用巨集LOSCFG_BASE_IPC_QUEUE_LIMIT定義的，每一個佇列queueID是queueID型別的，取值為[0,LOSCFG_BASE_IPC_QUEUE_LIMIT)，表示佇列池中各個佇列的編號。

⑴處的巨集從佇列池中獲取指定佇列編號QueueID對應的佇列控制塊。⑵處根據雙向連結串列節點readWriteList[OS_QUEUE_WRITE]獲取佇列控制塊記憶體地址。

⑴    #define GET_QUEUE_HANDLE(QueueID) (((LosQueueCB *)g_allQueue) + (QueueID))

⑵    #define GET_QUEUE_LIST(ptr) LOS_DL_LIST_ENTRY(ptr, LosQueueCB, readWriteList[OS_QUEUE_WRITE])

另外，佇列中還提供了比較重要的佇列讀取訊息操作相關的列舉和巨集。列舉QueueReadWrite區分佇列的讀和寫，列舉QueueHeadTail區分佇列的首和尾，列舉QueuePointOrNot區分讀寫訊息時是使用值還是指標。

佇列的操作型別使用3位元位的數字來表示，見巨集OS_QUEUE_OPERATE_TYPE的定義，其中高1位表示讀寫數值還是讀寫指標地址，中1位表示隊首還是隊尾，低1位表示讀取還是寫入。列舉和巨集的定義如下：

typedef enum {
    OS_QUEUE_READ,
    OS_QUEUE_WRITE
} QueueReadWrite;

typedef enum {
    OS_QUEUE_HEAD,
    OS_QUEUE_TAIL
} QueueHeadTail;

typedef enum {
    OS_QUEUE_NOT_POINT,
    OS_QUEUE_POINT
} QueuePointOrNot;

#define OS_QUEUE_OPERATE_TYPE(ReadOrWrite, HeadOrTail, PointOrNot)  \
                (((UINT32)(PointOrNot) << 2) | ((UINT32)(HeadOrTail) << 1) | (ReadOrWrite))
#define OS_QUEUE_READ_WRITE_GET(type) ((type) & (0x01))
#define OS_QUEUE_READ_HEAD     (OS_QUEUE_READ | (OS_QUEUE_HEAD << 1))
#define OS_QUEUE_READ_TAIL     (OS_QUEUE_READ | (OS_QUEUE_TAIL << 1))
#define OS_QUEUE_WRITE_HEAD    (OS_QUEUE_WRITE | (OS_QUEUE_HEAD << 1))
#define OS_QUEUE_WRITE_TAIL    (OS_QUEUE_WRITE | (OS_QUEUE_TAIL << 1))
#define OS_QUEUE_OPERATE_GET(type) ((type) & (0x03))
#define OS_QUEUE_IS_POINT(type)    ((type) & (0x04))
#define OS_QUEUE_IS_READ(type)     (OS_QUEUE_READ_WRITE_GET(type) == OS_QUEUE_READ)
#define OS_QUEUE_IS_WRITE(type)    (OS_QUEUE_READ_WRITE_GET(type) == OS_QUEUE_WRITE)
#define OS_READWRITE_LEN           2

2、佇列初始化

佇列在核心中預設開啟，使用者可以通過巨集LOSCFG_BASE_IPC_QUEUE進行關閉。開啟佇列的情況下，在系統啟動時，在kernel\src\los_init.c中呼叫OsQueueInit()進行佇列模組初始化。下面，我們分析下佇列初始化的程式碼。

⑴為佇列申請記憶體，如果申請失敗，則返回錯誤。⑵初始化雙向迴圈連結串列g_freeQueueList，維護未使用的佇列。⑶迴圈每一個佇列進行初始化，為每一個佇列節點指定索引queueID，並把佇列節點插入未使用佇列雙向連結串列g_freeQueueList。程式碼上可以看出，掛在未使用佇列雙向連結串列上的節點是每個佇列控制塊的寫阻塞任務連結串列節點.readWriteList[OS_QUEUE_WRITE]。

LITE_OS_SEC_TEXT_INIT UINT32 OsQueueInit(VOID)
{
    LosQueueCB *queueNode = NULL;
    UINT16 index;

    if (LOSCFG_BASE_IPC_QUEUE_LIMIT == 0) {
        return LOS_ERRNO_QUEUE_MAXNUM_ZERO;
    }

⑴  g_allQueue = (LosQueueCB *)LOS_MemAlloc(m_aucSysMem0, LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(LosQueueCB));
    if (g_allQueue == NULL) {
        return LOS_ERRNO_QUEUE_NO_MEMORY;
    }

    (VOID)memset_s(g_allQueue, LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(LosQueueCB),
                   0, LOSCFG_BASE_IPC_QUEUE_LIMIT * sizeof(LosQueueCB));

⑵  LOS_ListInit(&g_freeQueueList);
⑶  for (index = 0; index < LOSCFG_BASE_IPC_QUEUE_LIMIT; index++) {
        queueNode = ((LosQueueCB *)g_allQueue) + index;
        queueNode->queueID = index;
        LOS_ListTailInsert(&g_freeQueueList, &queueNode->readWriteList[OS_QUEUE_WRITE]);
    }

    return LOS_OK;
}

3、佇列常用操作

3.1 佇列建立

建立佇列函式是LOS_QueueCreate()，先看看該函式的引數：queueName是佇列名稱，實際上並沒有使用。len是佇列中訊息的數量，queueID是佇列編號，flags保留未使用。maxMsgSize是佇列中每條訊息的最大大小。

我們分析下建立佇列的程式碼。⑴處對引數進行校驗，佇列編碼不能為空，佇列訊息長度不能太大，佇列訊息數量和佇列訊息大小不能為0。⑵處計算訊息的實際最大大小msgSize，即maxMsgSize + sizeof(UINT32)訊息最大大小再加4個位元組，在訊息的最後4個位元組用來儲存訊息的實際長度。然後呼叫⑶處函式LOS_MemAlloc()為對佇列動態申請記憶體，如果記憶體申請失敗，則返回錯誤碼。

⑷處判斷g_freeQueueList是否為空，如果沒有可以使用的佇列，釋放前文申請的記憶體。⑸處如果g_freeQueueList不為空，則獲取第一個可用的佇列節點，接著從雙向連結串列g_freeQueueList中刪除，然後呼叫巨集GET_QUEUE_LIST獲取LosQueueCB *queueCB，初始化建立的佇列資訊，包含佇列的長度.queueLen、訊息大小.queueSize，佇列記憶體空間.queue，訊息狀態.queueState，可讀的數量.readWriteableCnt[OS_QUEUE_READ]為0，可寫的數量readWriteableCnt[OS_QUEUE_WRITE]為佇列訊息長度len，佇列頭位置.queueHead和尾位置.queueTail為0。

⑹初始化雙向連結串列.readWriteList[OS_QUEUE_READ]，阻塞在這個佇列上的讀訊息任務會掛在這個連結串列上。初始化雙向連結串列.readWriteList[OS_QUEUE_WRITE]，阻塞在這個佇列上的寫訊息任務會掛在這個連結串列上。初始化雙向連結串列.memList。⑺賦值給輸出引數*queueID，後續程式使用這個佇列編號對佇列進行其他操作。

LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueCreate(CHAR *queueName,
                                             UINT16 len,
                                             UINT32 *queueID,
                                             UINT32 flags,
                                             UINT16 maxMsgSize)
{
    LosQueueCB *queueCB = NULL;
    UINT32 intSave;
    LOS_DL_LIST *unusedQueue = NULL;
    UINT8 *queue = NULL;
    UINT16 msgSize;

    (VOID)queueName;
    (VOID)flags;

⑴  if (queueID == NULL) {
        return LOS_ERRNO_QUEUE_CREAT_PTR_NULL;
    }

    if (maxMsgSize > (OS_NULL_SHORT - sizeof(UINT32))) {
        return LOS_ERRNO_QUEUE_SIZE_TOO_BIG;
    }

    if ((len == 0) || (maxMsgSize == 0)) {
        return LOS_ERRNO_QUEUE_PARA_ISZERO;
    }
⑵  msgSize = maxMsgSize + sizeof(UINT32);

    /* Memory allocation is time-consuming, to shorten the time of disable interrupt,
       move the memory allocation to here. */
⑶  queue = (UINT8 *)LOS_MemAlloc(m_aucSysMem0, len * msgSize);
    if (queue == NULL) {
        return LOS_ERRNO_QUEUE_CREATE_NO_MEMORY;
    }

    intSave = LOS_IntLock();
⑷  if (LOS_ListEmpty(&g_freeQueueList)) {
        LOS_IntRestore(intSave);
        (VOID)LOS_MemFree(m_aucSysMem0, queue);
        return LOS_ERRNO_QUEUE_CB_UNAVAILABLE;
    }

⑸  unusedQueue = LOS_DL_LIST_FIRST(&(g_freeQueueList));
    LOS_ListDelete(unusedQueue);
    queueCB = (GET_QUEUE_LIST(unusedQueue));
    queueCB->queueLen = len;
    queueCB->queueSize = msgSize;
    queueCB->queue = queue;
    queueCB->queueState = OS_QUEUE_INUSED;
    queueCB->readWriteableCnt[OS_QUEUE_READ] = 0;
    queueCB->readWriteableCnt[OS_QUEUE_WRITE] = len;
    queueCB->queueHead = 0;
    queueCB->queueTail = 0;
⑹  LOS_ListInit(&queueCB->readWriteList[OS_QUEUE_READ]);
    LOS_ListInit(&queueCB->readWriteList[OS_QUEUE_WRITE]);
    LOS_ListInit(&queueCB->memList);
    LOS_IntRestore(intSave);

⑺  *queueID = queueCB->queueID;

    OsHookCall(LOS_HOOK_TYPE_QUEUE_CREATE, queueCB);

    return LOS_OK;
}

3.2 佇列刪除

我們可以使用函式LOS_QueueDelete(UINT32 queueID)來刪除佇列，下面通過分析原始碼看看如何刪除佇列的。

⑴處判斷佇列queueID是否超過LOSCFG_BASE_IPC_QUEUE_LIMIT，如果超過則返回錯誤碼。如果佇列編號沒有問題，獲取佇列控制塊LosQueueCB *queueCB。⑵處判斷要刪除的佇列處於未使用狀態，則跳轉到錯誤標籤QUEUE_END進行處理。⑶如果佇列的阻塞讀、阻塞寫任務列表不為空，或記憶體節點連結串列不為空，則不允許刪除，跳轉到錯誤標籤進行處理。⑷處檢驗佇列的可讀、可寫數量是否出錯。

⑸處使用指標UINT8 *queue儲存佇列的記憶體空間，⑹處把.queue置空，把.queueState設定為未使用OS_QUEUE_UNUSED，並把佇列節點插入未使用佇列雙向連結串列g_freeQueueList。接下來會需要呼叫⑺處函式LOS_MemFree()釋放佇列記憶體空間。

LITE_OS_SEC_TEXT_INIT UINT32 LOS_QueueDelete(UINT32 queueID)
{
    LosQueueCB *queueCB = NULL;
    UINT8 *queue = NULL;
    UINT32 intSave;
    UINT32 ret;

⑴  if (queueID >= LOSCFG_BASE_IPC_QUEUE_LIMIT) {
        return LOS_ERRNO_QUEUE_NOT_FOUND;
    }

    intSave = LOS_IntLock();
    queueCB = (LosQueueCB *)GET_QUEUE_HANDLE(queueID);
⑵  if (queueCB->queueState == OS_QUEUE_UNUSED) {
        ret = LOS_ERRNO_QUEUE_NOT_CREATE;
        goto QUEUE_END;
    }

⑶  if (!LOS_ListEmpty(&queueCB->readWriteList[OS_QUEUE_READ])) {
        ret = LOS_ERRNO_QUEUE_IN_TSKUSE;
        goto QUEUE_END;
    }

    if (!LOS_ListEmpty(&queueCB->readWriteList[OS_QUEUE_WRITE])) {
        ret = LOS_ERRNO_QUEUE_IN_TSKUSE;
        goto QUEUE_END;
    }

    if (!LOS_ListEmpty(&queueCB->memList)) {
        ret = LOS_ERRNO_QUEUE_IN_TSKUSE;
        goto QUEUE_END;
    }

⑷  if ((queueCB->readWriteableCnt[OS_QUEUE_WRITE] + queueCB->readWriteableCnt[OS_QUEUE_READ]) !=
        queueCB->queueLen) {
        ret = LOS_ERRNO_QUEUE_IN_TSKWRITE;
        goto QUEUE_END;
    }

⑸  queue = queueCB->queue;
⑹  queueCB->queue = (UINT8 *)NULL;
    queueCB->queueState = OS_QUEUE_UNUSED;
    LOS_ListAdd(&g_freeQueueList, &queueCB->readWriteList[OS_QUEUE_WRITE]);
    LOS_IntRestore(intSave);

    OsHookCall(LOS_HOOK_TYPE_QUEUE_DELETE, queueCB);

⑺  ret = LOS_MemFree(m_aucSysMem0, (VOID *)queue);
    return ret;

QUEUE_END:
    LOS_IntRestore(intSave);
    return ret;
}

下面就來看看佇列的讀寫，有2點需要注意：

• 隊首、隊尾的讀寫

只支援隊首讀取，不能隊尾讀取，否則就不算佇列了。除了正常的隊尾寫訊息外，還提供插隊機制，支援從隊首寫入。

• 佇列訊息資料內容

往佇列中寫入的訊息的型別有2種，即支援按地址寫入和按值寫入（帶拷貝）。按哪種型別寫入，就需要配對的按相應的型別去讀取。

佇列讀取介面的類別，歸納如下：

3.3 佇列讀取

我們知道有2個佇列讀取方法，按指標地址讀取的函式LOS_QueueRead()和按訊息數值讀取的函式LOS_QueueReadCopy()。我們先看下函式LOS_QueueRead()，該函式的引數有4個，佇列編號queueID，存放讀取到的訊息的緩衝區地址*bufferAddr，存放讀取到的訊息的緩衝區大小bufferSize，讀佇列訊息的等待超時時間timeOut。程式碼如下，我們分析下程式碼。

⑴處校驗傳入引數，佇列編號不能超出限制，傳入的指標不能為空，緩衝大小不能為0。如果timeout不為零，不能在中斷中讀取佇列。⑵處操作型別表示隊首讀取訊息指標，然後呼叫函式OsQueueOperate()進一步操作佇列。

LITE_OS_SEC_TEXT UINT32 LOS_QueueRead(UINT32 queueID, VOID *bufferAddr, UINT32 bufferSize, UINT32 timeOut)
{
    UINT32 ret;
    UINT32 operateType;

⑴  ret = OsQueueReadParameterCheck(queueID, bufferAddr, &bufferSize, timeOut);
    if (ret != LOS_OK) {
        return ret;
    }

⑵  operateType = OS_QUEUE_OPERATE_TYPE(OS_QUEUE_READ, OS_QUEUE_HEAD, OS_QUEUE_POINT);

    OsHookCall(LOS_HOOK_TYPE_QUEUE_READ, (LosQueueCB *)GET_QUEUE_HANDLE(queueID));

    return OsQueueOperate(queueID, operateType, bufferAddr, &bufferSize, timeOut);
}

我們進一步分析下函式OsQueueOperate()，這是是比較通用的封裝，讀取，寫入都會呼叫這個函式，我們以讀取佇列為例分析這個函式。⑴處獲取佇列的操作型別，為讀取操作。⑵處先呼叫函式OsQueueOperateParamCheck()進行引數校驗，校驗佇列是使用中的佇列，並對讀寫訊息大小進行校驗。⑶處如果可讀數量為0，無法讀取時，如果是零等待則返回錯誤碼。如果當前鎖任務排程，跳出函式執行。否則，執行⑷把當前任務放入佇列的讀取訊息阻塞佇列，然後觸發任務排程，後續的程式碼暫時不再執行。如果可讀的數量不為0，可以繼續讀取時，執行⑹處程式碼把可讀數量減1，然後繼續執行⑺處程式碼讀取佇列。

等讀取佇列阻塞超時，或者佇列可以讀取後，繼續執行⑸處的程式碼。如果是發生超時，佇列還不能讀取，更改任務狀態，跳出函式執行。如果佇列可以讀取了，繼續執行⑺處程式碼讀取佇列。⑻處在成功讀取佇列後，如果有任務阻塞在寫入佇列，則獲取阻塞連結串列中的第一個任務resumedTask，然後呼叫喚醒函式OsSchedTaskWake()把待恢復的任務放入就緒佇列，觸發一次任務排程。如果無阻塞任務，則把可寫入的數量加1。

UINT32 OsQueueOperate(UINT32 queueID, UINT32 operateType, VOID *bufferAddr, UINT32 *bufferSize, UINT32 timeOut)
{
    LosQueueCB *queueCB = NULL;
    LosTaskCB *resumedTask = NULL;
    UINT32 ret;
⑴  UINT32 readWrite = OS_QUEUE_READ_WRITE_GET(operateType);
    UINT32 readWriteTmp = !readWrite;

    UINT32 intSave = LOS_IntLock();

    queueCB = (LosQueueCB *)GET_QUEUE_HANDLE(queueID);
⑵  ret = OsQueueOperateParamCheck(queueCB, operateType, bufferSize);
    if (ret != LOS_OK) {
        goto QUEUE_END;
    }

⑶  if (queueCB->readWriteableCnt[readWrite] == 0) {
        if (timeOut == LOS_NO_WAIT) {
            ret = OS_QUEUE_IS_READ(operateType) ? LOS_ERRNO_QUEUE_ISEMPTY : LOS_ERRNO_QUEUE_ISFULL;
            goto QUEUE_END;
        }

        if (g_losTaskLock) {
            ret = LOS_ERRNO_QUEUE_PEND_IN_LOCK;
            goto QUEUE_END;
        }

        LosTaskCB *runTsk = (LosTaskCB *)g_losTask.runTask;
⑷      OsSchedTaskWait(&queueCB->readWriteList[readWrite], timeOut);
        LOS_IntRestore(intSave);
        LOS_Schedule();

        intSave = LOS_IntLock();
⑸      if (runTsk->taskStatus & OS_TASK_STATUS_TIMEOUT) {
            runTsk->taskStatus &= ~OS_TASK_STATUS_TIMEOUT;
            ret = LOS_ERRNO_QUEUE_TIMEOUT;
            goto QUEUE_END;
        }
    } else {
⑹       queueCB->readWriteableCnt[readWrite]--;
    }

⑺   OsQueueBufferOperate(queueCB, operateType, bufferAddr, bufferSize);
⑻  if (!LOS_ListEmpty(&queueCB->readWriteList[readWriteTmp])) {
        resumedTask = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&queueCB->readWriteList[readWriteTmp]));
        OsSchedTaskWake(resumedTask);
        LOS_IntRestore(intSave);
        LOS_Schedule();
        return LOS_OK;
    } else {
⑼      queueCB->readWriteableCnt[readWriteTmp]++;
    }

QUEUE_END:
    LOS_IntRestore(intSave);
    return ret;
}

我們再繼續看下函式OsQueueBufferOperate()是具體如何讀取佇列的。⑴處switch-case語句根據操作型別獲取操作位置。對於⑵頭部讀取的情況，先獲取讀取位置queuePosition。然後，如果當前頭節點位置.queueHead加1等於佇列訊息長度，頭節點位置.queueHead設定為0，否則加1。對於⑶頭部寫入的情況，如果當前頭節點位置.queueHead等於0，頭節點位置.queueHead設定為佇列訊息長度減1即queueCB->queueLen - 1，否則頭節點位置.queueHead減1即可。然後，獲取要寫入的位置queuePosition。對於⑷尾部寫入的情況，先獲取寫入位置queuePosition。然後，如果當前尾節點位置.queueTail加1等於佇列訊息長度，尾節點位置.queueTail設定為0，否則加1。

⑸處基於獲取的佇列讀取位置獲取佇列訊息節點queueNode。⑹處判斷操作型別如果是按指標讀寫訊息，直接讀取訊息節點的資料寫入指標對應的緩衝區*(UINT32 *)bufferAddr，或直接把指標對應的緩衝區*(UINT32 *)bufferAddr資料寫入訊息節點即可。我們接著看如何按數資料讀寫訊息，⑺處程式碼用於讀取資料訊息。每個訊息節點的後4個位元組儲存的是訊息的長度，首先獲取訊息的長度msgDataSize，然後把訊息內容讀取到bufferAddr。再看看⑻處如何寫入佇列訊息，首先把訊息內容寫入到queueNode，然後再把訊息長度的內容寫入到queueNode + queueCB->queueSize - sizeof(UINT32)，就是每個訊息節點的後4位元組。

static INLINE VOID OsQueueBufferOperate(LosQueueCB *queueCB, UINT32 operateType,
                                                                VOID *bufferAddr, UINT32 *bufferSize)
{
    UINT8 *queueNode = NULL;
    UINT32 msgDataSize;
    UINT16 queuePosion;
    errno_t rc;

    /* get the queue position */
⑴  switch (OS_QUEUE_OPERATE_GET(operateType)) {
        case OS_QUEUE_READ_HEAD:
⑵          queuePosion = queueCB->queueHead;
            ((queueCB->queueHead + 1) == queueCB->queueLen) ? (queueCB->queueHead = 0) : (queueCB->queueHead++);
            break;

        case OS_QUEUE_WRITE_HEAD:
⑶          (queueCB->queueHead == 0) ? (queueCB->queueHead = (queueCB->queueLen - 1)) : (--queueCB->queueHead);
            queuePosion = queueCB->queueHead;
            break;

        case OS_QUEUE_WRITE_TAIL:
⑷          queuePosion = queueCB->queueTail;
            ((queueCB->queueTail + 1) == queueCB->queueLen) ? (queueCB->queueTail = 0) : (queueCB->queueTail++);
            break;

        default:
            PRINT_ERR("invalid queue operate type!\n");
            return;
    }

⑸  queueNode = &(queueCB->queue[(queuePosion * (queueCB->queueSize))]);

⑹  if (OS_QUEUE_IS_POINT(operateType)) {
      if (OS_QUEUE_IS_READ(operateType)) {
            *(UINT32 *)bufferAddr = *(UINT32 *)(VOID *)queueNode;
        } else {
            *(UINT32 *)(VOID *)queueNode = *(UINT32 *)bufferAddr;  // change to pp when calling OsQueueOperate
        }
    } else {
⑺      if (OS_QUEUE_IS_READ(operateType)) {
            msgDataSize = *((UINT32 *)(UINTPTR)((queueNode + queueCB->queueSize) - sizeof(UINT32)));
            rc = memcpy_s((VOID *)bufferAddr, *bufferSize, (VOID *)queueNode, msgDataSize);
            if (rc != EOK) {
                PRINT_ERR("%s[%d] memcpy failed, error type = %u\n", __FUNCTION__, __LINE__, rc);
                return;
            }

            *bufferSize = msgDataSize;
        } else {
⑻          *((UINT32 *)(UINTPTR)((queueNode + queueCB->queueSize) - sizeof(UINT32))) = *bufferSize;
            rc = memcpy_s((VOID *)queueNode, queueCB->queueSize, (VOID *)bufferAddr, *bufferSize);
            if (rc != EOK) {
                PRINT_ERR("%s[%d] memcpy failed, error type = %u\n", __FUNCTION__, __LINE__, rc);
                return;
            }
        }
    }
}

3.4 佇列寫入

我們知道，有4個佇列寫入方法，2個隊尾寫入，2個隊首寫入，分別包含按指標地址寫入訊息和按數值寫入訊息。LOS_QueueWrite()會呼叫LOS_QueueWriteCopy()，LOS_QueueWriteHead()會呼叫LOS_QueueWriteHeadCopy()，然後指定不同的操作型別後，會進一步呼叫前文已經分析過的函式OsQueueOperate()。

小結

本文帶領大家一起剖析了鴻蒙輕核心的佇列模組的原始碼，包含佇列的結構體、佇列池初始化、佇列建立刪除、讀寫訊息等。感謝閱讀，如有任何問題、建議，都可以留言給我們： https://gitee.com/openharmony/kernel_liteos_m/issues 。為了更容易找到鴻蒙輕核心程式碼倉，建議訪問 https://gitee.com/openharmony/kernel_liteos_m ，關注Watch、點贊Star、並Fork到自己賬戶下，謝謝。

 

點選關注，第一時間瞭解華為雲新鮮技術~