(学习日记)2024.03.31:UCOSIII第二十八节:消息队列常用函数

写在前面:
由于时间的不足与学习的碎片化,写博客变得有些奢侈。
但是对于记录学习(忘了以后能快速复习)的渴望一天天变得强烈。
既然如此
不如以天为单位,以时间为顺序,仅仅将博客当做一个知识学习的目录,记录笔者认为最通俗、最有帮助的资料,并尽量总结几句话指明本质,以便于日后搜索起来更加容易。


标题的结构如下:“类型”:“知识点”——“简短的解释”
部分内容由于保密协议无法上传。


点击此处进入学习日记的总目录

2024.03.31:UCOSIII第二十八节:消息队列常用函数

  • 四十二、UCOSIII:消息队列常用函数
    • 1、创建消息队列函数OSQCreate()
    • 2、消息队列删除函数OSQDel()
    • 3、消息队列发送函数OSQPost()
      • 1. OSQPost()函数
      • 2. OS_QPost()函数
      • 3. OS_MsgQPut()函数
      • 4. OS_Post()函数
    • 4、消息队列获取函数OSQPend()
      • 1. OSQPend()函数
      • 2. OS_MsgQGet()函数
      • 3. OS_Pend()函数

四十二、UCOSIII:消息队列常用函数

1、创建消息队列函数OSQCreate()

要使用 μC/OS的消息队列必须先声明和创建消息队列,OSQCreate()用于创建一个新的队列。

队列就是一个数据结构, 用于任务间的数据的传递。每创建一个新的队列都需要为其分配RAM,在创建的时候我们需要自己定义一个消息队列结构体, 其内存是由编译器自动分配的。

OSQCreate的源码具体如下

void  OSQCreate (OS_Q        *p_q,          //(1)     //消息队列指针
                CPU_CHAR    *p_name,        //(2)     //消息队列名称
                OS_MSG_QTY   max_qty,       //(3)     //消息队列大小(不能为0)
                OS_ERR      *p_err)         //(4)     //返回错误类型

{
    CPU_SR_ALLOC();//(5)//使用到临界段(在关/开中断时)时必须用到该宏,该宏声明和
    //定义一个局部变量,用于保存关中断前的 CPU 状态寄存器
    // SR(临界段关中断只需保存SR),开中断时将该值还原。

#ifdef OS_SAFETY_CRITICAL//(6)//如果启用了安全检测
    if (p_err == (OS_ERR *)0) {         //如果错误类型实参为空
        OS_SAFETY_CRITICAL_EXCEPTION(); //执行安全检测异常函数
        return;                         //返回,停止执行
    }
#endif
#ifdef OS_SAFETY_CRITICAL_IEC61508  //如果启用了安全关键
//如果在调用OSSafetyCriticalStart()后创建
    if (OSSafetyCriticalStartFlag == DEF_TRUE) {
        *p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME; //错误类型为“非法创建内核对象”
        return;                                  //返回,停止执行
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u//(7)//如果启用了中断中非法调用检测
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) { //如果该函数是在中断中被调用
        *p_err = OS_ERR_CREATE_ISR;             //错误类型为“在中断中创建对象”
        return;                                //返回,停止执行
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u//(8)       //如果启用了参数检测
    if (p_q == (OS_Q *)0) {           //如果 p_q 为空
        *p_err = OS_ERR_OBJ_PTR_NULL;  //错误类型为“创建对象为空”
        return;                       //返回,停止执行
    }
    if (max_qty == (OS_MSG_QTY)0) { //(9)//如果 max_qty = 0
        *p_err = OS_ERR_Q_SIZE;        //错误类型为“队列空间为0”
        return;                       //返回,停止执行
    }
#endif

    OS_CRITICAL_ENTER();             //进入临界段
    p_q->Type    = OS_OBJ_TYPE_Q; //(10)//标记创建对象数据结构为消息队列
    p_q->NamePtr = p_name;        //(11)//标记消息队列的名称
    OS_MsgQInit(&p_q->MsgQ,          //初始化消息队列
    max_qty);       //(12)
    OS_PendListInit(&p_q->PendList); //(13)   //初始化该消息队列的等待列表

#if OS_CFG_DBG_EN > 0u//如果启用了调试代码和变量
    OS_QDbgListAdd(p_q);             //将该队列添加到消息队列双向调试链表
#endif
    OSQQty++;                    //(14)//消息队列个数加1

    OS_CRITICAL_EXIT_NO_SCHED();            //退出临界段(无调度)
    *p_err = OS_ERR_NONE;           //错误类型为“无错误”
}
  • (1):消息队列指针,在创建之前我们要定义一个队列的数据结构,然后将消息队列指针指向该队列。
  • (2):消息队列的名称,字符串形式,这个名称一般与消息队列名称一致,为了方便调试。
  • (3):消息队列的大小,也就是消息队列的可用消息个数最大为多少,一旦确定无法修改。
  • (4):用于保存返回的错误类型。
  • (5):使用到临界段(在关/开中断时)时必须用到该宏,该宏声明和定义一个局部变量, 用于保存关中断前的 CPU 状态寄存器SR(临界段关中断只需保存SR),开中断时将该值还原。
  • (6):如果启用了安全检测,在编译时则会包含安全检测相关的代码,如果错误类型实参为空, 系统会执行安全检测异常函数,然后返回,停止执行。
  • (7):如果启用了中断中非法调用检测,在编译时则会包含中断非法调用检测相关的代码, 如果该函数是在中断中被调用,则是非法的,返回错误类型为“在中断中创建对象”的错误代码,并且退出,不执行创建队列操作。
  • (8):如果启用了参数检测,在编译时则会包含参数检测相关的代码, 如果 p_q 参数为空,返回错误类型为“创建对象为空”的错误代码,并且退出,不执行创建队列操作。
  • (9):如果 max_qty参数为 0,表示不存在消息空间,这也是错误的, 返回错误类型为“队列空间为0”的错误代码,并且退出,不执行创建队列操作。
  • (10):标记创建对象数据结构为消息队列。
  • (11):初始化消息队列的名称。
  • (12):调用OS_MsgQInit()函数初始化消息队列,其实就是初始化消息队列结构的相关信息
  • (13):初始化消息队列的阻塞列表,消息队列的阻塞列表是用于记录阻塞在此消息队列上的任务。
  • (14):OSQQty是系统中的一个全局变量, 用于记录已经创建的消息队列个数,现在创建队列完毕,所以该变量要加一。

其中,OS_MsgQInit()源码如下

void  OS_MsgQInit (OS_MSG_Q    *p_msg_q, //消息队列指针
                OS_MSG_QTY   size)    //消息队列空间
{
    p_msg_q->NbrEntriesSize = (OS_MSG_QTY)size; //消息队列可存放消息数目
    p_msg_q->NbrEntries     = (OS_MSG_QTY)0;    //消息队列目前可用消息数
    p_msg_q->NbrEntriesMax  = (OS_MSG_QTY)0;    //可用消息数的最大历史记录
    p_msg_q->InPtr          = (OS_MSG   *)0;    //队列的入队指针
    p_msg_q->OutPtr         = (OS_MSG   *)0;    //队列的出队指针
}

消息队列创建完成的示意图具体见图
在这里插入图片描述
在创建消息队列的时候,是需要用户自己定义消息队列的句柄的。
但是需要注意的是,定义了队列的句柄并不等于创建了队列。
创建队列必须是调用消息队列创建函数进行创建,否则,以后根据队列句柄使用消息队列的其他函数的时候会发生错误。
用户通过消息队列句柄就可使用消息队列进行发送与获取消息的操作,用户可以根据返回的错误代码进行判断消息队列是否创建成功。

消息队列创建函数OSQCreate()使用实例具体

OS_Q queue;                             //声明消息队列

OS_ERR      err;

/* 创建消息队列 queue */
OSQCreate ((OS_Q         *)&queue,            //指向消息队列的指针
        (CPU_CHAR     *)"Queue For Test",  //队列的名字
        (OS_MSG_QTY    )20,                //最多可存放消息的数目
        (OS_ERR       *)&err);             //返回错误类型

2、消息队列删除函数OSQDel()

队列删除函数是根据队列结构(队列句柄)直接删除的,删除之后这个消息队列的所有信息都会被系统清空,而且不能再次使用这个消息队列了。
需要注意的是,如果某个消息队列没有被定义,那也是无法被删除的。

想要使用消息队列删除函数就必须将OS_CFG_Q_DEL_EN宏定义配置为1, 其函数源码具体如下:

#if OS_CFG_Q_DEL_EN > 0u//如果启用了 OSQDel() 函数
OS_OBJ_QTY  OSQDel (OS_Q    *p_q,   //(1)//消息队列指针
                    OS_OPT   opt,  //(2)//选项
            OS_ERR  *p_err) //(3)//返回错误类型
{
    OS_OBJ_QTY     cnt;
    OS_OBJ_QTY     nbr_tasks;
    OS_PEND_DATA  *p_pend_data;
    OS_PEND_LIST  *p_pend_list;
    OS_TCB        *p_tcb;
    CPU_TS         ts;
    CPU_SR_ALLOC(); //使用到临界段(在关/开中断时)时必须用到该宏,该宏声明和
    //定义一个局部变量,用于保存关中断前的 CPU 状态寄存器
    // SR(临界段关中断只需保存SR),开中断时将该值还原。

#ifdef OS_SAFETY_CRITICAL	//(4)//如果启用(默认禁用)了安全检测
    if (p_err == (OS_ERR *)0) {         //如果错误类型实参为空
        OS_SAFETY_CRITICAL_EXCEPTION(); //执行安全检测异常函数
        return ((OS_OBJ_QTY)0);         //返回0(有错误),停止执行
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u	//(5)//如果启用了中断中非法调用检测
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {  //如果该函数在中断中被调用
        *p_err = OS_ERR_DEL_ISR;                 //错误类型为“在中断中中止等待”
        return ((OS_OBJ_QTY)0);                 //返回0(有错误),停止执行
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u	//(6)//如果启用了参数检测
    if (p_q == (OS_Q *)0) {               //如果 p_q 为空
        *p_err =  OS_ERR_OBJ_PTR_NULL;     //错误类型为“对象为空”
        return ((OS_OBJ_QTY)0u);          //返回0(有错误),停止执行
    }
    switch (opt) {              //(7)//根据选项分类处理
    case OS_OPT_DEL_NO_PEND:          //如果选项在预期内
    case OS_OPT_DEL_ALWAYS:
    break;                       //直接跳出

    default:                        //(8)
            *p_err =  OS_ERR_OPT_INVALID; //如果选项超出预期
    return ((OS_OBJ_QTY)0u);     //返回0(有错误),停止执行
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u	//(9)//如果启用了对象类型检测
    if (p_q->Type != OS_OBJ_TYPE_Q) { //如果 p_q 不是消息队列类型
        *p_err = OS_ERR_OBJ_TYPE;      //错误类型为“对象类型有误”
        return ((OS_OBJ_QTY)0);       //返回0(有错误),停止执行
    }
#endif

    CPU_CRITICAL_ENTER();                                  //关中断
    p_pend_list = &p_q->PendList;      //(10)//获取消息队列的等待列表
    cnt         = p_pend_list->NbrEntries;  //(11)//获取等待该队列的任务数
    nbr_tasks   = cnt;               //(12)//按照任务数目逐个处理
    switch (opt) {                   //(13)//根据选项分类处理
    case OS_OPT_DEL_NO_PEND:        //(14)//如果只在没有任务等待的情况下删除队列
    if (nbr_tasks == (OS_OBJ_QTY)0) {//(15)//如果没有任务在等待该队列
#if OS_CFG_DBG_EN > 0u//如果启用了调试代码和变量
            OS_QDbgListRemove(p_q);          //将该队列从消息队列调试列表移除
#endif
            OSQQty--;                //(16)//消息队列数目减1
            OS_QClr(p_q);            //(17)//清除该队列的内容
            CPU_CRITICAL_EXIT();                      //开中断
            *p_err = OS_ERR_NONE;     //(18)//错误类型为“无错误”
        } else {  //(19)//如果有任务在等待该队列
            CPU_CRITICAL_EXIT();               //开中断
            *p_err = OS_ERR_TASK_WAITING;      //错误类型为“有任务在等待该队列”
        }
break;

case OS_OPT_DEL_ALWAYS:                //(20)//如果必须删除信号量
        OS_CRITICAL_ENTER_CPU_EXIT();                  //进入临界段,重开中断
        ts = OS_TS_GET();                              //获取时间戳
while (cnt > 0u) {              //(21)//逐个移除该队列等待列表中的任务
            p_pend_data = p_pend_list->HeadPtr;
            p_tcb       = p_pend_data->TCBPtr;
            OS_PendObjDel((OS_PEND_OBJ *)((void *)p_q),
                        p_tcb,
                        ts);
                        cnt--;                              //(22)
        }
#if OS_CFG_DBG_EN > 0u//如果启用了调试代码和变量
        OS_QDbgListRemove(p_q);            //将该队列从消息队列调试列表移除
#endif
        OSQQty--;                          //(23)//消息队列数目减1
        OS_QClr(p_q);                      //(24)//清除消息队列内容
        OS_CRITICAL_EXIT_NO_SCHED();                  //退出临界段(无调度)
        OSSched();                        //(25)//调度任务
        *p_err = OS_ERR_NONE;              //(26)//错误类型为“无错误”
        break;                                        //跳出

        default://(27)//如果选项超出预期
        CPU_CRITICAL_EXIT();              //开中断
        *p_err = OS_ERR_OPT_INVALID;                   //错误类型为“选项非法”
        break;                                        //跳出
    }
    return (nbr_tasks);                 //返回删除队列前等待其的任务数
}
#endif
  • (1):消息队列指针,指向要删除的消息队列。
  • (2):操作消息队列的选项,具体在后面讲解。
  • (3):用于保存返回的错误类型。
  • (4):如果启用(默认禁用)了安全检测,在编译时则会包含安全检测相关的代码,如果错误类型实参为空, 系统会执行安全检测异常函数,然后返回,停止执行。
  • (5):如果启用了中断中非法调用检测,在编译时则会包含中断非法调用检测相关的代码, 如果该函数是在中断中被调用,则是非法的,返回错误类型为“在中断中删除”的错误代码,并且退出,不执行删除队列操作。
  • (6):如果启用了参数检测,在编译时则会包含参数检测相关的代码,如果 p_q 参数为空, 返回错误类型为“删除对象为空”的错误代码,并且退出,不执行删除队列操作。
  • (7):根据选项分类处理,如果选项在预期内,直接跳出switch语句。
  • (8):如果选项超出预期,就退出,不执行删除队列操作。
  • (9):如果启用了对象类型检测,在编译时则会包含对象类型检测相关代码,如果 p_q 不是消息队列类型, 那么返回错误类型为“对象类型有误”的错误代码,并且退出,不执行删除队列操作。
  • (10):程序能执行到这里,说明传入的参数都是正确的,此时可以执行删除队列操作, 系统首先获取消息队列中的等待列表,通过p_pend_list变量进行消息队列等待列表的访问。
  • (11):获取阻塞在该队列上的任务个数。
  • (12):按照任务数目逐个处理。
  • (13):根据选项分类处理。
  • (14):如果如果删除选项是只在没有任务等待的情况下删除队列,系统就会判断有没有任务阻塞在改队列上。
  • (15):如果没有任务在等待该队列,那就执行删除操作。
  • (16):系统的消息队列数目减1。
  • (17):清除该队列的内容。
  • (18):返回错误类型为“无错误”的错误代码。
  • (19):而如果有任务在等待该队列,那么就没法进行删除操作,返回错误类型为“有任务在等待该队列”的错误代码。
  • (20):如果删除操作的选项是必须删除消息队列,无论是否有任务阻塞在该消息队列上,系统都会进行删除操作。
  • (21):根据消息队列当前等待的任务个数,逐个移除该队列等待列表中的任务。
  • (22):调用OS_PendObjDel()函数将阻塞在内核对象(如信号量)上的任务从阻塞态恢复, 此时系统在删除内核对象, 删除之后,这些等待事件的任务需要被恢复。每移除一个,消息队列的任务个数就减一, 当没有任务阻塞在该队列上,就进行删除队列操作。
  • (23):系统的消息队列数目减1。
  • (24):清除消息队列内容。
  • (25):发起一次调度任务。
  • (26):返回错误类型为“无错误”的错误代码。
  • (27):而如果选项超出预期,返回错误类型为“选项非法”的错误代码,然后退出。

OS_PendObjDel()源码如下

void  OS_PendObjDel (OS_PEND_OBJ  *p_obj,  	//(1)      //被删除对象的类型
                    OS_TCB       *p_tcb, 	//(2)        //任务控制块指针
                    CPU_TS        ts)    	//(3)        //信号量被删除时的时间戳
{
switch (p_tcb->TaskState)             	//(4)//根据任务状态分类处理
    {
    case OS_TASK_STATE_RDY:                             //如果任务是就绪状态
    case OS_TASK_STATE_DLY:                             //如果任务是延时状态
    case OS_TASK_STATE_SUSPENDED:                       //如果任务是挂起状态
    case OS_TASK_STATE_DLY_SUSPENDED:            //如果任务是在延时中被挂起
    break;                           	//(5)
    //这些情况均与等待无关,直接跳出

    case OS_TASK_STATE_PEND:                    //如果任务是无期限等待状态
    case OS_TASK_STATE_PEND_TIMEOUT:            //如果任务是有期限等待状态
        if (p_tcb->PendOn == OS_TASK_PEND_ON_MULTI)
        //如果任务在等待多个信号量或消息队列
        {
            OS_PendObjDel1(p_obj,              //强制解除任务对某一对象的等待
                        p_tcb,
                        ts);         	//(6)
        }
#if (OS_MSG_EN > 0u)	//(7)//如果启用了任务队列或消息队列
        p_tcb->MsgPtr     = (void *)0;        //清除(复位)任务的消息域
        p_tcb->MsgSize    = (OS_MSG_SIZE)0u;
#endif
        p_tcb->TS         = ts;          	//(8)
        //保存等待被中止时的时间戳到任务控制块
        OS_PendListRemove(p_tcb);      	//(9)//将任务从所有等待列表中移除
        OS_TaskRdy(p_tcb);              	//(10)//让任务进准备运行
        p_tcb->TaskState  = OS_TASK_STATE_RDY;  	//(11)//修改任务状态为就绪状态
        p_tcb->PendStatus = OS_STATUS_PEND_DEL;	//(12)//标记任务的等待对象被删除
        p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING;	//(13)//标记任务目前没有等待任何对象
        break;                                       //跳出

    case OS_TASK_STATE_PEND_SUSPENDED:      //如果任务在无期限等待中被挂起
    case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED: //如果任务在有期限等待中被挂起
        if (p_tcb->PendOn == OS_TASK_PEND_ON_MULTI)
        //如果任务在等待多个信号量或消息队列
        {
            OS_PendObjDel1(p_obj,          //强制解除任务对某一对象的等待
                        p_tcb,
                        ts);                	//(14)
        }
#if (OS_MSG_EN > 0u)	//(15)//如果启用了任务队列或消息队列
        p_tcb->MsgPtr     = (void      *)0;	//(16)//清除(复位)任务的消息域
        p_tcb->MsgSize    = (OS_MSG_SIZE)0u;
#endif
        p_tcb->TS         = ts;      	//(17)
        //保存等待被中止时的时间戳到任务控制块
        OS_TickListRemove(p_tcb);     	//(18)//让任务脱离节拍列表
        OS_PendListRemove(p_tcb);     	//(19)//将任务从所有等待列表中移除
        p_tcb->TaskState  = OS_TASK_STATE_SUSPENDED; 	//(20)//修改任务状态为挂起状态
        p_tcb->PendStatus = OS_STATUS_PEND_DEL;	//(21)//标记任务的等待对象被删除
        p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING;  //标记任务目前没有等待任何对象
        break;                                        //跳出

    default:                               	//(22)//如果任务状态超出预期
    break;                                        //不需处理,直接跳出
    }
}
  • (1):被删除对象的类型(如消息队列、信号量、互斥量、事件等)。
  • (2):任务控制块指针。
  • (3):内核对象被删除时的时间戳。
  • (4):根据任务状态分类处理。
  • (5):如果任务是就绪状态、延时状态、挂起状态或者是在延时中被挂起, 这些任务状态均与等待内核对象是无关的,在内核对象被删除的时候无需进行任何操作。
  • (6):如果任务是无期限等待状态或者是有期限等待状态, 那么在内核对象被删除的时候需要将这些任务恢复。如果这些任务在等待多个内核对象(信号量或消息队列等), 那么就需要强制解除任务对某一对象的等待,比如现在删除的是消息队列, 那么就将该任务对消息队列的等待进行解除。
  • (7):如果启用了任务队列或消息队列,清除(复位)任务的消息指针,任务等待的消息大小为0。
  • (8):保存等待被中止时的时间戳到任务控制块。
  • (9):调用OS_PendListRemove()函数将任务从所有等待列表中移除。
  • (10):调用OS_TaskRdy()函数让任务进入就绪态参与系统调度,准备运行。
  • (11):修改任务状态为就绪状态。
  • (12):标记任务的等待对象被删除。
  • (13):标记任务目前没有等待任何对象。
  • (14):如果任务在无期限等待中被挂起或者在有期限等待中被挂起, 也是需要将这些等待内核对象的任务从等待中移除,但是由于在等待中被挂起,那么就不会将这些任务恢复为就绪态, 仅仅是将任务从等待列表中移除。如果任务在等待多个信号量或消息队列,同样也是讲任务从等待的对象中移除即可。
  • (15):如果启用了任务队列或消息队列。
  • (16):需要清除(复位)任务的消息指针,任务等待的消息大小为0。
  • (17):保存等待被中止时的时间戳到任务控制块。
  • (18):调用OS_TickListRemove()函数让任务脱离节拍列表。
  • (19):调用OS_PendListRemove()函数将任务从所有等待列表中移除。
  • (20):修改任务状态为挂起状态,因为在等待中被挂起,此时即使任务不等的内核对象了,它还是处于挂起态。
  • (21):任务的等待对象被删除,标记任务目前没有等待任何对象。
  • (22):如果任务状态超出预期,不需处理,直接跳出。

消息队列删除函数OSQDel()的使用也是很简单的,只需要传入要删除的消息队列的句柄与选项还有保存返回的错误类型即可。

调用函数时, 系统将删除这个消息队列。
需要注意的是在调用删除消息队列函数前,系统应存在已创建的消息队列。
如果删除消息队列时, 有任务正在等待消息,则不应该进行删除操作,删除之后的消息队列就不可用了。

删除消息队列函数OSQDel()的使用实例具体如下:

OS_Q queue;                             //声明消息队列

OS_ERR      err;

/* 删除消息队列 queue */
OSQDel ((OS_Q         *)&queue,            //指向消息队列的指针
OS_OPT_DEL_NO_PEND,
(OS_ERR       *)&err);             //返回错误类型

3、消息队列发送函数OSQPost()

1. OSQPost()函数

任务或者中断服务程序都可以给消息队列发送消息,当发送消息时,如果队列未满,就说明运行信息入队。
μC/OS会从消息池中取出一个消息, 挂载到消息队列的末尾(FIFO发送方式)。
如果是LIFO发送方式,则将消息挂载到消息队列的头部, 然后将消息中MsgPtr成员变量指向要发送的消息(此处可以理解为添加要发送的信息到消息(块)中)。
如果系统有任务阻塞在消息队列中,那么在发送了消息队列的时候,会将任务解除阻塞,其源码具体如下:

void  OSQPost (OS_Q         *p_q,     //(1)   //消息队列指针
void         *p_void,  //(2)  //消息指针
            OS_MSG_SIZE   msg_size,//(3)      //消息大小(单位:字节)
            OS_OPT        opt,     //(4)      //选项
            OS_ERR       *p_err)   //(5)      //返回错误类型
{
    CPU_TS  ts;



#ifdef OS_SAFETY_CRITICAL//(6)//如果启用(默认禁用)了安全检测
    if (p_err == (OS_ERR *)0) {         //如果错误类型实参为空
        OS_SAFETY_CRITICAL_EXCEPTION(); //执行安全检测异常函数
        return;                         //返回,停止执行
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u//(7)//如果启用了参数检测
    if (p_q == (OS_Q *)0) {            //如果 p_q 为空
        *p_err = OS_ERR_OBJ_PTR_NULL;   //错误类型为“内核对象为空”
        return;                        //返回,停止执行
    }
    switch (opt) {                   //(8)//根据选项分类处理
    case OS_OPT_POST_FIFO:             //如果选项在预期内
    case OS_OPT_POST_LIFO:
    case OS_OPT_POST_FIFO | OS_OPT_POST_ALL:
    case OS_OPT_POST_LIFO | OS_OPT_POST_ALL:
    case OS_OPT_POST_FIFO | OS_OPT_POST_NO_SCHED:
    case OS_OPT_POST_LIFO | OS_OPT_POST_NO_SCHED:
    case OS_OPT_POST_FIFO | OS_OPT_POST_ALL | OS_OPT_POST_NO_SCHED:
    case OS_OPT_POST_LIFO | OS_OPT_POST_ALL | OS_OPT_POST_NO_SCHED:
    break;                       //直接跳出

    default:                       //(9)//如果选项超出预期
        *p_err =  OS_ERR_OPT_INVALID; //错误类型为“选项非法”
    return;                      //返回,停止执行
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u//(10)//如果启用了对象类型检测
    if (p_q->Type != OS_OBJ_TYPE_Q) { //如果 p_q 不是消息队列类型
        *p_err = OS_ERR_OBJ_TYPE;      //错误类型为“对象类型错误”
        return;                       //返回,停止执行
    }
#endif

    ts = OS_TS_GET();                 //获取时间戳

#if OS_CFG_ISR_POST_DEFERRED_EN > 0u//(11)//如果启用了中断延迟发布
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {  //如果该函数在中断中被调用
        OS_IntQPost((OS_OBJ_TYPE)OS_OBJ_TYPE_Q, //将该消息发布到中断消息队列
                    (void      *)p_q,
                    (void      *)p_void,
                    (OS_MSG_SIZE)msg_size,
                    (OS_FLAGS   )0,
                    (OS_OPT     )opt,
                    (CPU_TS     )ts,
                    (OS_ERR    *)p_err);
    return;                                //返回(尚未发布),停止执行
    }
#endif

    OS_QPost(p_q,                              //将消息按照普通方式
            p_void,
            msg_size,
            opt,
            ts,
            p_err);                 //(12)
}
  • (1):消息队列指针,指向要发送消息的队列。
  • (2):消息指针,指向任何类型的消息数据。
  • (3):消息的大小(单位:字节)。
  • (4):发送消息的选项,在os.h中定义
#define  OS_OPT_POST_FIFO   (OS_OPT)(0x0000u)/* 默认采用FIFO方式发送 */
#define  OS_OPT_POST_LIFO  (OS_OPT)(0x0010u)/*采用LIFO方式发送消息*/
#define  OS_OPT_POST_1   (OS_OPT)(0x0000u)/*将消息发布到最高优先级的等待任务*/
#define  OS_OPT_POST_ALL (OS_OPT)(0x0200u)/*向所有等待的任务广播消息*/

#define  OS_OPT_POST_NO_SCHED (OS_OPT)(0x8000u)/*发送消息但是不进行任务调度*/

  • (5):保存返回的错误类型,用户可以根据此变量得知错误的原因。
  • (6):如果启用(默认禁用)了安全检测,在编译时则会包含安全检测相关的代码,如果错误类型实参为空, 系统会执行安全检测异常函数,然后返回,停止执行。
  • (7):如果启用了参数检测,在编译时则会包含参数检测相关的代码,如果 p_q 参数为空, 返回错误类型为“内核对象为空”的错误代码,并且退出,不执行发送消息操作。
  • (8):根据opt选项进行分类处理,如果选项在预期内,直接退出,其实在这里只是对选项的一个检查, 看看传入的选项参数是否正确。
  • (9):如果opt选项超出预期,返回错误类型为“选项非法”的错误代码,并且退出,不执行发送消息操作。
  • (10):如果启用了对象类型检测,在编译时则会包含对象类型检测相关代码, 如果 p_q 不是消息队列类型,那么返回错误类型为“对象类型有误”的错误代码,并且退出,不执行发送消息操作。
  • (11):如果启用了中断延迟发布,并且发送消息的函数是在中断中被调用, 此时就不该立即发送消息,而是将消息的发送放在指定发布任务中,此时系统就将消息发布到租单消息队列中, 等待到中断发布任务唤醒再发送消息,该函数会在中断管理章节详细讲解。
  • (12):而如果不是在中断中调用OSQPost()函数,或者未启用中断延迟发布, 则直接调用OS_QPost()函数进行消息的发送

2. OS_QPost()函数

OS_QPost()函数源码具体如下:

void  OS_QPost (OS_Q         *p_q,      //消息队列指针
                void         *p_void,   //消息指针
                OS_MSG_SIZE   msg_size, //消息大小(单位:字节)
                OS_OPT        opt,      //选项
                CPU_TS        ts,       //消息被发布时的时间戳
                OS_ERR       *p_err)    //返回错误类型
{
    OS_OBJ_QTY     cnt;
    OS_OPT         post_type;
    OS_PEND_LIST  *p_pend_list;
    OS_PEND_DATA  *p_pend_data;
    OS_PEND_DATA  *p_pend_data_next;
    OS_TCB        *p_tcb;
    CPU_SR_ALLOC();  //使用到临界段(在关/开中断时)时必须用到该宏,该宏声明和
    //定义一个局部变量,用于保存关中断前的 CPU 状态寄存器
    // SR(临界段关中断只需保存SR),开中断时将该值还原。

    OS_CRITICAL_ENTER();                              //进入临界段
    p_pend_list = &p_q->PendList;                   //取出该队列的等待列表
    if (p_pend_list->NbrEntries == (OS_OBJ_QTY)0)    //(1)//如果没有任务在等待该队列
    {
        if ((opt & OS_OPT_POST_LIFO) == (OS_OPT)0)   //把消息发布到队列的末端
        {
            post_type = OS_OPT_POST_FIFO;   //(2)
        }
        else//把消息发布到队列的前端
        {
            post_type = OS_OPT_POST_LIFO;   //(3)
        }

        OS_MsgQPut(&p_q->MsgQ,                    //把消息放入消息队列
                p_void,
                msg_size,
                post_type,
                ts,
                p_err);                     //(4)
        OS_CRITICAL_EXIT();                          //退出临界段
    return;                                      //返回,执行完毕
    }
    /* 如果有任务在等待该队列 */
    if ((opt & OS_OPT_POST_ALL) != (OS_OPT)0)    //(5)//如果要把消息发布给所有等待任务
    {
        cnt = p_pend_list->NbrEntries;              //获取等待任务数目
    }
    else//如果要把消息发布给一个等待任务
    {
        cnt = (OS_OBJ_QTY)1;          //(6)//要处理的任务数目为1
    }
    p_pend_data = p_pend_list->HeadPtr; //(7)//获取等待列表的头部(任务)
    while (cnt > 0u)                     //(8)//根据要发布的任务数目逐个发布
    {
        p_tcb            = p_pend_data->TCBPtr;             //(9)
        p_pend_data_next = p_pend_data->NextPtr;
        OS_Post((OS_PEND_OBJ *)((void *)p_q),       //把消息发布给任务
                p_tcb,
                p_void,
                msg_size,
                ts);                                //(10)
        p_pend_data = p_pend_data_next;
        cnt--;                              //(11)
    }
    OS_CRITICAL_EXIT_NO_SCHED();            //退出临界段(无调度)
    if ((opt & OS_OPT_POST_NO_SCHED) == (OS_OPT)0)  //如果没选择“发布完不调度任务”
    {
        OSSched();                        //(12)//任务调度
    }
    *p_err = OS_ERR_NONE;                            //错误类型为“无错误”
}
  • (1):使用局部变量p_pend_list获取队列的等待列表, 然后查看等待列表中是否有任务在等待,分情况处理,因为没有任务等待就直接将消息放入队列中即可, 而有任务在等待则有可能需要唤醒该任务。
  • (2):如果没有任务在等待,系统就会看看用户发送消息的选项是什么, 如果是发送到细细道来的末端(队尾,FIFO方式),那么表示发送类型的post_type变量就被设置为OS_OPT_POST_FIFO。
  • (3):否则就设置为OS_OPT_POST_LIFO, 采用LIFO方式发送消息。将消息发送到队列的前端(对头)。
  • (4):调用OS_MsgQPut()函数将消息放入队列中, 执行完毕就退出
  • (5):而如果有任务在等待消息,会有两种情况, 一种是将消息发送到所有等待任务(广播消息),另一种是只将消息发送到等待任务中最高优先级的任务。 根据opt选项选择其中一种方式进行发送消息,如果要把消息发送给所有等待任务,那就首先获取到等待任务个数, 保存在要处理任务个数cnt变量中。
  • (6):否则就是把消息发布给一个等待任务,要处理任务个数cnt变量为1。
  • (7):获取等待列表中的第一个任务。
  • (8):根据要处理任务个数cnt逐个将消息发送出去。
  • (9):获取任务的控制块。
  • (10):调用OS_Post()函数把消息发送给任务
  • (11):每处理完一个任务,cnt变量就要减一,等到为0的时候退出while循环。
  • (12):如果没选择“发送完不调度任务”,在发送消息完成的时候就要进行一次任务调度。

3. OS_MsgQPut()函数

OS_MsgQPut()源码如下:

void  OS_MsgQPut (OS_MSG_Q     *p_msg_q,   //消息队列指针
                void         *p_void,    //消息指针
                OS_MSG_SIZE   msg_size,  //消息大小(单位:字节)
                OS_OPT        opt,       //选项
                CPU_TS        ts,        //消息被发布时的时间戳
                OS_ERR       *p_err)     //返回错误类型
{
    OS_MSG  *p_msg;
    OS_MSG  *p_msg_in;



#ifdef OS_SAFETY_CRITICAL//如果启用了安全检测
    if (p_err == (OS_ERR *)0)            //如果错误类型实参为空
    {
        OS_SAFETY_CRITICAL_EXCEPTION();  //执行安全检测异常函数
        return;                          //返回,停止执行
    }
#endif

    if (p_msg_q->NbrEntries >= p_msg_q->NbrEntriesSize)   //如果消息队列已没有可用空间
    {
        *p_err = OS_ERR_Q_MAX;                      //错误类型为“队列已满”
        return;                                     //返回,停止执行
    }

    if (OSMsgPool.NbrFree == (OS_MSG_QTY)0)    //如果消息池没有可用消息
    {
        *p_err = OS_ERR_MSG_POOL_EMPTY;         //错误类型为“消息池没有消息”
        return;                                //返回,停止执行
    }
    /* 从消息池获取一个消息(暂存于 p_msg )*/
    p_msg             = OSMsgPool.NextPtr; //(1)//将消息控制块从消息池移除
    OSMsgPool.NextPtr = p_msg->NextPtr;     //(2)//指向下一个消息(取走首个消息)
    OSMsgPool.NbrFree--;                   //(3)//消息池可用消息数减1
    OSMsgPool.NbrUsed++;                    //(4)//消息池被用消息数加1
    if (OSMsgPool.NbrUsedMax < OSMsgPool.NbrUsed)  //(5)//更新消息被用最大数目的历史记录
    {
        OSMsgPool.NbrUsedMax = OSMsgPool.NbrUsed;
    }
    /* 将获取的消息插入消息队列 */
    if (p_msg_q->NbrEntries == (OS_MSG_QTY)0)  //(6)//如果消息队列目前没有消息
    {
        p_msg_q->InPtr         = p_msg;           //将其入队指针指向该消息
        p_msg_q->OutPtr        = p_msg;          //出队指针也指向该消息
        p_msg_q->NbrEntries    = (OS_MSG_QTY)1;  //队列的消息数为1
        p_msg->NextPtr         = (OS_MSG *)0;    //该消息的下一个消息为空
    }
    else//(7)//如果消息队列目前已有消息
    {
    if ((opt & OS_OPT_POST_LIFO) == OS_OPT_POST_FIFO)   //如果用FIFO方式插入队列,
        {
            p_msg_in           = p_msg_q->InPtr;//将消息插入入队端,入队
            p_msg_in->NextPtr  = p_msg;                     //指针指向该消息。
            p_msg_q->InPtr     = p_msg;
            p_msg->NextPtr     = (OS_MSG *)0;
        }
    else//(8)//如果用LIFO方式插入队列,
        {
            p_msg->NextPtr     = p_msg_q->OutPtr;  //将消息插入出队端,出队
            p_msg_q->OutPtr    = p_msg;            //指针指向该消息。
        }
        p_msg_q->NbrEntries++;               //(9)//消息队列的消息数目加1
    }
    if (p_msg_q->NbrEntriesMax < p_msg_q->NbrEntries)  //(10)//更新改消息队列的最大消息
    {
        p_msg_q->NbrEntriesMax = p_msg_q->NbrEntries;       //数目的历史记录。
    }
    p_msg->MsgPtr  = p_void;                //(11)//给该消息填写消息内容
    p_msg->MsgSize = msg_size;              //(12)//给该消息填写消息大小
    p_msg->MsgTS   = ts;                    //(13)//填写发布该消息时的时间戳
    *p_err          = OS_ERR_NONE;          // (14)//错误类型为“无错误”
}
  • (1):从消息池获取一个消息(暂存于 p_msg ), OSMsgPool是消息池,它的NextPtr成员变量指向消息池中可用的消息。
  • (2):更新消息池中NextPtr成员变量,指向消息池中下一个可用的消息。
  • (3):消息池可中用消息个数减1。
  • (4):消息池已使用的消息个数加1。
  • (5):更新消息被用最大数目的历史记录。
  • (6):将获取的消息插入消息队列,插入队列时分两种情况:一种是队列中有消息情况, 另一种是队列中没有消息情况。如果消息队列目前没有消息,将队列中的入队指针指向该消息,出队指针也指向该消息, 因为现在消息放进来了,只有一个消息,无论是入队还是出队,都是该消息,更新队列的消息个数为1,该消息的下一个消息为空。
  • (7):而如果消息队列目前已有消息,那么又分两种入队的选项, 是先进先出排队呢还是后进先出排队呢?如果采用FIFO方式插入队列,那么就将消息插入入队端, 消息队列的最后一个消息的NextPtr指针就指向该消息,然后入队的消息成为队列中排队的最后一个消息, 那么需要更新它的下一个消息为空。
  • (8):而如果采用LIFO方式插入队列, 将消息插入出队端,队列中出队指针OutPtr指向该消息,需要出队的时候就是 该消息首先出队,这就是后进先出原则。
  • (9):无论是采用哪种方式入队,消息队列的消息数目都要加1。
  • (10):更新改消息队列的最大消息。
  • (11):既然消息已经入队了,那肯定得添加我们自己的消息内容啊, 需要给该消息填写消息内容,消息中的MsgPtr指针指向我们的消息内容。
  • (12):给该消息填写我们发送的消息大小。
  • (13):填写发布该消息时的时间戳。
  • (14):当程序执行到这里,表面就是没有错误,返回错误类型为“无错误”的错误代码。

4. OS_Post()函数

OS_Post()源码如下:

void  OS_Post (OS_PEND_OBJ  *p_obj,     	//(1) //内核对象类型指针
            OS_TCB       *p_tcb,     	//(2)    //任务控制块
            void         *p_void,    	//(3)    //消息
            OS_MSG_SIZE   msg_size,  	//(4)    //消息大小
            CPU_TS        ts)        	//(5)    //时间戳
{
    switch (p_tcb->TaskState)           	//(6)//根据任务状态分类处理
    {
    case OS_TASK_STATE_RDY:                   //如果任务处于就绪状态
    case OS_TASK_STATE_DLY:                   //如果任务处于延时状态
    case OS_TASK_STATE_SUSPENDED:             //如果任务处于挂起状态
    case OS_TASK_STATE_DLY_SUSPENDED:
    //如果任务处于延时中被挂起状态
    break;                           	//(7)//不用处理,直接跳出

    case OS_TASK_STATE_PEND:             //如果任务处于无期限等待状态
    case OS_TASK_STATE_PEND_TIMEOUT:         //如果任务处于有期限等待状态
        if (p_tcb->PendOn == OS_TASK_PEND_ON_MULTI) 	//(8)
        //如果任务在等待多个信号量或消息队列
        {
            OS_Post1(p_obj,                   //标记哪个内核对象被发布
                    p_tcb,
                    p_void,
                    msg_size,
                    ts);                    	//(9)
        }
        else	//(10)
        //如果任务不是在等待多个信号量或消息队列
        {
#if (OS_MSG_EN > 0u)
//如果启用了任务队列或消息队列
            p_tcb->MsgPtr  = p_void;        	//(11)//保存消息到等待任务
            p_tcb->MsgSize = msg_size;
#endif
            p_tcb->TS      = ts;           	//(12)//保存时间戳到等待任务
        }
        if (p_obj != (OS_PEND_OBJ *)0)        //如果内核对象不为空
        {
            OS_PendListRemove(p_tcb);     	//(13)//从等待列表移除该等待任务
#if OS_CFG_DBG_EN > 0u//如果启用了调试代码和变量
            OS_PendDbgNameRemove(p_obj,         //移除内核对象的调试名
                                p_tcb);
#endif
        }
        OS_TaskRdy(p_tcb);         	//(14)     //让该等待任务准备运行
        p_tcb->TaskState  = OS_TASK_STATE_RDY;  	//(15)//任务状态改为就绪状态
        p_tcb->PendStatus = OS_STATUS_PEND_OK;    	//(16)//清除等待状态
        p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING; 	//(17)//标记不再等待
break;

    case OS_TASK_STATE_PEND_SUSPENDED:
    //如果任务在无期限等待中被挂起
    case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:
    //如果任务在有期限等待中被挂起
    if (p_tcb->PendOn == OS_TASK_PEND_ON_MULTI)     	//(18)
    //如果任务在等待多个信号量或消息队列
        {
            OS_Post1(p_obj,                    //标记哪个内核对象被发布
                    p_tcb,
                    p_void,
                    msg_size,
                    ts);                    	//(19)
        }
        else	//(20)
        //如果任务不在等待多个信号量或消息队列
        {
#if (OS_MSG_EN > 0u)//如果启用了调试代码和变量
            p_tcb->MsgPtr  = p_void;       	//(21)//保存消息到等待任务
            p_tcb->MsgSize = msg_size;
#endif
            p_tcb->TS      = ts;                //保存时间戳到等待任务
        }
        OS_TickListRemove(p_tcb);       	//(22)//从节拍列表移除该等待任务
        if (p_obj != (OS_PEND_OBJ *)0)          //如果内核对象为空
        {
            OS_PendListRemove(p_tcb);     	//(23)//从等待列表移除该等待任务
#if OS_CFG_DBG_EN > 0u//如果启用了调试代码和变量
            OS_PendDbgNameRemove(p_obj,        //移除内核对象的调试名
                                p_tcb);
#endif
        }
        p_tcb->TaskState  = OS_TASK_STATE_SUSPENDED;  	//(24)//任务状态改为被挂起状态
        p_tcb->PendStatus = OS_STATUS_PEND_OK;   	//(25)//清除等待状态
        p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING; 	//(26)//标记不再等待
        break;

    default:                               	//(27)//如果任务状态超出预期
    break;                                           //直接跳出
    }
}
  • (1):内核对象类型指针,表示是哪个内核对象进行发布(释放/发送)操作。
  • (2):任务控制块指针,指向被操作的任务。
  • (3):消息指针。
  • (4):消息大小。
  • (5):时间戳。
  • (6):根据任务状态分类处理。
  • (7):如果任务处于就绪状态、延时状态、挂起状态或者是延时中被挂起状态,都不用处理, 直接退出,因为现在这个操作是内核对象进行发布(释放)操作,而这些状态的任务是与内核对象无关的状态,
    也就是这些任务没在等待相关的内核对象(如消息队列、信号量等)。
  • (8):如果任务处于无期限等待状态或者是有期限等待状态,那么就需要处理了,先看看任务是不是在等待多个内核对象。
  • (9):如果任务在等待多个信号量或消息队列, 就调用OS_Post1()函数标记一下是哪个内核对象进行发布(释放)操作。
  • (10):如果任务不是在等待多个信号量或消息队列,就直接操作即可。
  • (11):如果启用了任务队列或消息队列(启用了OS_MSG_EN宏定义), 保存消息到等待任务控制块的MsgPtr成员变量中, 将消息的大小保存到等待任务控制块的MsgSize成员变量中。
  • (12):保存时间戳到等待任务控制块的TS成员变量中。
  • (13):如果内核对象不为空,调用OS_PendListRemove()函数从等待列表移除该等待任务。
  • (14):调用OS_TaskRdy()函数让该等待任务准备运行。
  • (15):任务状态改为就绪状态。
  • (16):清除任务的等待状态。
  • (17):标记任务不再等待。
  • (18):如果任务在无期限等待中被挂起,或者任务在有期限等待中被挂起,反正任务就是在等待中被挂起了, 也能进行内核对象发布(释放)操作,同理,先看看任务是不是在等待多个内核对象。
  • (19):如果任务在等待多个信号量或消息队列, 就调用OS_Post1()函数标记一下是哪个内核对象进行发布(释放)操作。
  • (20):如果任务不在等待多个信号量或消息队列,就直接操作即可。
  • (21):如果启用了任务队列或消息队列(启用了OS_MSG_EN宏定义), 保存消息到等待任务控制块的MsgPtr成员变量中,将消息的大小保存到等待任务控制块的MsgSize成员变量中。
  • (22):调用OS_TickListRemove()函数将任务从节拍列表中移除。
  • (23):从等待列表移除该等待任务。
  • (24):任务状态改为被挂起状态。
  • (25):清除任务的等待状态。
  • (26):标记任务不再等待。
  • (27):如果任务状态超出预期,直接跳出。

从消息队列的入队操作(发送消息)我们可以看出:
μC/OS支持向所有任务发送消息,也支持只向一个任务发送消息, 这样子系统的灵活性就会大大提高,与此同时,μC/OS还支持中断延迟发布,不在中断中直接发送消息。

消息队列的发送函数OSQPost()使用实例具体如下:

/* 发送消息到消息队列 queue */
OSQPost ((OS_Q        *)&queue,                             //消息变量指针
        (void        *)"Binghuo μC/OS-III",
        //要发送的数据的指针,将内存块首地址通过队列“发送出去”
        (OS_MSG_SIZE  )sizeof ( "Binghuo μC/OS-III" ),     //数据字节大小
        (OS_OPT       )OS_OPT_POST_FIFO | OS_OPT_POST_ALL,
        //先进先出和发布给全部任务的形式
        (OS_ERR      *)&err);          

4、消息队列获取函数OSQPend()

当任务试图从队列中的获取消息时,用户可以指定一个阻塞超时时间,当且仅当消息队列中有消息的时候,任务才能获取到消息。
在这段时间中,如果队列为空,该任务将保持阻塞状态以等待队列消息有效。
当其他任务或中断服务程序往其等待的队列中写入了数据, 该任务将自动由阻塞态转为就绪态。
当任务等待的时间超过了用户指定的阻塞时间,即使队列中尚无有效消息, 任务也会自动从阻塞态转为就绪态。

1. OSQPend()函数

OSQPend()函数源码具体如下:

void  *OSQPend (OS_Q         *p_q,       //(1)        //消息队列指针
                OS_TICK       timeout,   //(2)        //等待期限(单位:时钟节拍)
                OS_OPT        opt,       //(3)        //选项
                OS_MSG_SIZE  *p_msg_size,//(4)        //返回消息大小(单位:字节)
                CPU_TS       *p_ts,      //(5)        //获取等到消息时的时间戳
                OS_ERR       *p_err)     //(6)        //返回错误类型
{
    OS_PEND_DATA  pend_data;
    void         *p_void;
    CPU_SR_ALLOC(); //使用到临界段(在关/开中断时)时必须用到该宏,该宏声明和
    //定义一个局部变量,用于保存关中断前的 CPU 状态寄存器
    // SR(临界段关中断只需保存SR),开中断时将该值还原。

#ifdef OS_SAFETY_CRITICAL//(7)//如果启用(默认禁用)了安全检测
    if (p_err == (OS_ERR *)0)           //如果错误类型实参为空
    {
        OS_SAFETY_CRITICAL_EXCEPTION(); //执行安全检测异常函数
        return ((void *)0);             //返回0(有错误),停止执行
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u//(8)//如果启用了中断中非法调用检测
    if (OSIntNestingCtr > (OS_NESTING_CTR)0)   //如果该函数在中断中被调用
    {
        *p_err = OS_ERR_PEND_ISR;               //错误类型为“在中断中中止等待”
        return ((void *)0);                    //返回0(有错误),停止执行
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u//(9)//如果启用了参数检测
    if (p_q == (OS_Q *)0)                 //如果 p_q 为空
    {
        *p_err = OS_ERR_OBJ_PTR_NULL;      //错误类型为“对象为空”
        return ((void *)0);               //返回0(有错误),停止执行
    }
    if (p_msg_size == (OS_MSG_SIZE *)0)   //如果 p_msg_size 为空
    {
        *p_err = OS_ERR_PTR_INVALID;       //错误类型为“指针不可用”
    return ((void *)0);               //返回0(有错误),停止执行
    }
    switch (opt)                    //(10)//根据选项分类处理
    {
    case OS_OPT_PEND_BLOCKING:        //如果选项在预期内
    case OS_OPT_PEND_NON_BLOCKING:
    break;                       //直接跳出

    default:                     //(11)//如果选项超出预期
        *p_err = OS_ERR_OPT_INVALID;  //返回错误类型为“选项非法”
    return ((void *)0);          //返回0(有错误),停止执行
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u//(12)//如果启用了对象类型检测
    if (p_q->Type != OS_OBJ_TYPE_Q)    //如果 p_q 不是消息队列类型
    {
        *p_err = OS_ERR_OBJ_TYPE;       //错误类型为“对象类型有误”
        return ((void *)0);            //返回0(有错误),停止执行
    }
#endif

    if (p_ts != (CPU_TS *)0)    //(13)        //如果 p_ts 非空
    {
        *p_ts  = (CPU_TS  )0;       //初始化(清零)p_ts,待用于返回时间戳
    }

    CPU_CRITICAL_ENTER();  //关中断
    p_void = OS_MsgQGet(&p_q->MsgQ,        //(14)//从消息队列获取一个消息
                        p_msg_size,
                        p_ts,
                        p_err);
    if (*p_err == OS_ERR_NONE)            //(15)//如果获取消息成功
    {
        CPU_CRITICAL_EXIT();                              //开中断
        return (p_void);                                  //返回消息内容
    }
    /* 如果获取消息不成功 */          //(16)
    if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) //如果选择了不阻塞任务
    {
        CPU_CRITICAL_EXIT();                              //开中断
        *p_err = OS_ERR_PEND_WOULD_BLOCK;           //错误类型为“等待渴求阻塞”
        return ((void *)0);                       //返回0(有错误),停止执行
    }
    else//(17)//如果选择了阻塞任务
    {
    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0)//(18)//如果调度器被锁
        {
            CPU_CRITICAL_EXIT();                  //开中断
            *p_err = OS_ERR_SCHED_LOCKED;         //错误类型为“调度器被锁”
            return ((void *)0);                   //返回0(有错误),停止执行
        }
    }
    /* 如果调度器未被锁 */
    OS_CRITICAL_ENTER_CPU_EXIT();          //(19)//锁调度器,重开中断
    OS_Pend(&pend_data,
    //阻塞当前任务,等待消息队列,
            (OS_PEND_OBJ *)((void *)p_q),         //将当前任务脱离就绪列表,并
            OS_TASK_PEND_ON_Q,                   //插入节拍列表和等待列表。
            timeout);                       //(20)
    OS_CRITICAL_EXIT_NO_SCHED();          //开调度器,但不进行调度

    OSSched();                            //(21)
    //找到并调度最高优先级就绪任务
    /* 当前任务(获得消息队列的消息)得以继续运行 */
    CPU_CRITICAL_ENTER();                // (22)//关中断
    switch (OSTCBCurPtr->PendStatus)      //(23)
    //根据当前运行任务的等待状态分类处理
    {
    case OS_STATUS_PEND_OK:                 //(24)//如果等待状态正常
        p_void     = OSTCBCurPtr->MsgPtr;   // (25)
        //从(发布时放于)任务控制块提取消息
        *p_msg_size = OSTCBCurPtr->MsgSize;  //提取消息大小
        if (p_ts  != (CPU_TS *)0)                    //如果 p_ts 非空
        {
            *p_ts   =  OSTCBCurPtr->TS;         //获取任务等到消息时的时间戳
        }
        *p_err      = OS_ERR_NONE;                    //错误类型为“无错误”
        break;                                       //跳出

    case OS_STATUS_PEND_ABORT:             //(26)//如果等待被中止
        p_void     = (void      *)0;                 //返回消息内容为空
        *p_msg_size = (OS_MSG_SIZE)0;                 //返回消息大小为0
        if (p_ts  != (CPU_TS *)0)                    //如果 p_ts 非空
        {
            *p_ts   =  OSTCBCurPtr->TS;        //获取等待被中止时的时间戳
        }
        *p_err      = OS_ERR_PEND_ABORT;      //错误类型为“等待被中止”
        break;                                       //跳出

    case OS_STATUS_PEND_TIMEOUT:           //(27)//如果等待超时
        p_void     = (void      *)0;                 //返回消息内容为空
        *p_msg_size = (OS_MSG_SIZE)0;                 //返回消息大小为0
        if (p_ts  != (CPU_TS *)0)                    //如果 p_ts 非空
        {
            *p_ts   = (CPU_TS  )0;                    //清零 p_ts
        }
        *p_err      = OS_ERR_TIMEOUT;                 //错误类型为“等待超时”
    break;                                       //跳出

    case OS_STATUS_PEND_DEL:             //(28)//如果等待的内核对象被删除
        p_void     = (void      *)0;                 //返回消息内容为空
        *p_msg_size = (OS_MSG_SIZE)0;                 //返回消息大小为0
        if (p_ts  != (CPU_TS *)0)                    //如果 p_ts 非空
        {
            *p_ts   =  OSTCBCurPtr->TS;          //获取对象被删时的时间戳
        }
        *p_err      = OS_ERR_OBJ_DEL;           //错误类型为“等待对象被删”
    break;                                       //跳出

    default:                               //(29)//如果等待状态超出预期
        p_void     = (void      *)0;                 //返回消息内容为空
        *p_msg_size = (OS_MSG_SIZE)0;                 //返回消息大小为0
        *p_err      = OS_ERR_STATUS_INVALID;          //错误类型为“状态非法”
        break;                                       //跳出
    }
    CPU_CRITICAL_EXIT();                                  //开中断
return(p_void);                      //(30)//返回消息内容
}
  • (1):消息队列指针,指向要获取消息的队列。
  • (2):指定阻塞时间(单位:时钟节拍)。
  • (3):获取消息的选项,在os.h中有定义。
  • (4):用于保存返回获取的消息大小(单位:字节)。
  • (5):用于保存返回等到消息时的时间戳。
  • (6):用于保存返回的错误类型,用户可以根据此变量得知错误的原因。
  • (7):如果启用(默认禁用)了安全检测,在编译时则会包含安全检测相关的代码, 如果错误类型实参为空,系统会执行安全检测异常函数,然后返回,停止执行。
  • (8):如果启用了中断中非法调用检测,并且如果该函数在中断中被调用, 则返回错误类型为“在中断获取消息”的错误代码,然后退出,停止执行。
  • (9):如果启用了参数检测,在编译时则会包含参数检测相关的代码, 如果 p_q 参数为空,返回错误类型为“内核对象为空”的错误代码,并且退出,不执行获取消息操作。
  • (10):根据opt选项进行分类处理,如果选项在预期内,直接退出, 其实在这里只是对选项的一个检查,看看传入的选项参数是否正确。
  • (11):如果opt选项超出预期, 返回错误类型为“选项非法”的错误代码,并且退出,不执行获取消息操作。
  • (12):如果启用了对象类型检测,在编译时则会包含对象类型检测相关代码, 如果 p_q 不是消息队列类型,那么返回错误类型为“对象类型有误”的错误代码,并且退出,不执行获取消息操作。
  • (13):如果 p_ts 非空,就初始化(清零)p_ts,待用于返回时间戳。
  • (14):调用OS_MsgQGet()函数从消息队列获取一个消息
  • (15):如果获取消息成功,就返回消息的内容。
  • (16):如果获取消息不成功,并且用户选择了不阻塞等待, 则返回错误类型为“等待渴求阻塞(OS_ERR_PEND_WOULD_BLOCK)”的错误代码,并且返回0,表示没有获取到消息。
  • (17):当获取消息不成功的时候,用户选择了阻塞等待,那么就会将任务状态变为阻塞态以等待消息。
  • (18):判断一下调度器是否被锁,如果被锁了,则返回错误类型为“调度器被锁”的错误代码,然后退出。
  • (19):如果调度器未被锁,就锁定调度器,重新打开中断。
    为什么刚刚调度器被锁就错误的呢?而现在又要锁定调度器?
    那是因为之前锁定的调度器不是由这个函数进行锁定的, 这是不允许的,因为现在要阻塞当前任务,而调度器锁定了就表示无法进行任务调度,这也是不允许的。
    那为什么又要关闭调度器呢, 因为接下来的操作是需要操作队列与任务的列表,这个时间就不会很短,系统不希望有其他任务来操作任务列表。这样可能引起其他任务解除阻塞, 这可能会发生优先级翻转。
    比如任务A的优先级低于当前任务,但是在当前任务进入阻塞的过程中,任务A却因为其他原因解除阻塞了, 那系统肯定是会去运行任务A,这显然是要绝对禁止的。
    挂起调度器意味着任务不能切换并且不准调用可能引起任务切换的API函数, 所以锁定调度器、打开中断这样的处理,既不会影响中断的响应,又避免了其他任务来操作队列与任务的列表。
  • (20):调用OS_Pend()函数将当前任务脱离就绪列表, 并根据用户指定的阻塞时间插入节拍列表和队列等待列表, 然后打开调度器,但不进行调度
  • (21):在这里就进行一次任务的调度。
  • (22):程序能执行到这里,就说明大体上有两种情况,要么是消息队列中有消息入队,任务获取到消息了; 任务还没获取到消息(任务没获取到消息的情况有很多种),无论是哪种情况,都先把中断关掉再说。
  • (23):根据当前运行任务的等待状态分类处理。
  • (24):如果任务状态是OS_STATUS_PEND_OK,则表示任务获取到消息了。
  • (25):从任务控制块中提取消息,这是因为在发送消息给任务的时候, 会将消息放入任务控制块的MsgPtr成员变量中,然后继续提取消息大小,如果p_ts非空,记录获取任务等到消息时的时间戳, 返回错误类型为“无错误”的错误代码,跳出switch语句。
  • (26):如果任务在等待(阻塞)被中止,则返回消息内容为空,返回消息大小为0, 如果p_ts非空,获取等待被中止时的时间戳,返回错误类型为“等待被中止”的错误代码,跳出switch语句。
  • (27):如果等待(阻塞)超时,说明等待的时间过去了,任务也没获取到消息, 则返回消息内容为空,返回消息大小为0,如果p_ts非空,将p_ts清零,返回错误类型为“等待超时”的错误代码,跳出switch语句。
  • (28):如果等待的内核对象被删除,则返回消息内容为空,返回消息大小为0, 如果p_ts非空,获取对象被删时的时间戳,返回错误类型为“等待对象被删”的错误代码,跳出switch语句。
  • (29):如果等待状态超出预期,则返回消息内容为空,返回消息大小为0, 返回错误类型为“状态非法”的错误代码,跳出switch语句。
  • (30):打开中断,返回消息内容。

2. OS_MsgQGet()函数

OS_MsgQGet()函数从消息队列获取一个消息,其源码具体如下:

void  *OS_MsgQGet (OS_MSG_Q     *p_msg_q,     //消息队列
                OS_MSG_SIZE  *p_msg_size,  //返回消息大小
                CPU_TS       *p_ts,        //返回某些操作的时间戳
                OS_ERR       *p_err)       //返回错误类型
{
    OS_MSG  *p_msg;
    void    *p_void;



#ifdef OS_SAFETY_CRITICAL//如果启用(默认禁用)了安全检测
    if (p_err == (OS_ERR *)0)           //如果错误类型实参为空
    {
        OS_SAFETY_CRITICAL_EXCEPTION(); //执行安全检测异常函数
        return ((void *)0);             //返回空消息,停止执行
    }
#endif

    if (p_msg_q->NbrEntries == (OS_MSG_QTY)0) //(1)//如果消息队列没有消息
    {
        *p_msg_size = (OS_MSG_SIZE)0;             //返回消息长度为0
        if (p_ts != (CPU_TS *)0)                 //如果 p_ts 非空
        {
            *p_ts  = (CPU_TS  )0;                 //清零 p_ts
        }
        *p_err = OS_ERR_Q_EMPTY;                  //错误类型为“队列没消息”
        return ((void *)0);                      //返回空消息,停止执行
    }
    /* 如果消息队列有消息 */
    p_msg           = p_msg_q->OutPtr;    //(2)//从队列的出口端提取消息
    p_void          = p_msg->MsgPtr;     //(3)//提取消息内容
    *p_msg_size      = p_msg->MsgSize;   //(4)//提取消息长度
    if (p_ts != (CPU_TS *)0)             //(5)//如果 p_ts 非空
    {
        *p_ts  = p_msg->MsgTS;                   //获取消息被发布时的时间戳
    }

    p_msg_q->OutPtr = p_msg->NextPtr;    //(6)//修改队列的出队指针

    if (p_msg_q->OutPtr == (OS_MSG *)0)  //(7)//如果队列没有消息了
    {
        p_msg_q->InPtr      = (OS_MSG   *)0;  //清零出队指针
        p_msg_q->NbrEntries = (OS_MSG_QTY)0; //清零消息数
    }
    else//(8)//如果队列还有消息
    {
        p_msg_q->NbrEntries--;                  //队列的消息数减1
    }
    /* 从消息队列提取完消息信息后,将消息释放回消息池供继续使用 */
    p_msg->NextPtr    = OSMsgPool.NextPtr;   //(9)//消息插回消息池
    OSMsgPool.NextPtr = p_msg;
    OSMsgPool.NbrFree++;                    //(10)//消息池的可用消息数加1
    OSMsgPool.NbrUsed--;                    //(11)//消息池的已用消息数减1

    *p_err             = OS_ERR_NONE;            //错误类型为“无错误”
    return (p_void);                        //(12)//返回消息内容
}
  • (1):如果消息队列目前没有可用消息,返回消息长度为0, 并且返回错误类型为“队列没消息”的错误代码和空消息,停止执行。
  • (2):而如果队列中有消息,则从队列的出口端提取消息。
  • (3):提取消息内容。
  • (4):提取消息长度。
  • (5):如果p_ts非空,获取消息入队时的时间戳。
  • (6):修改队列的出队指针。
  • (7):如果队列没有消息了,就将出队指针与消息个数清零。
  • (8):如果队列还有消息,队列的消息个数减1。
  • (9):消息插回消息池,以便重复利用。
  • (10):消息池的可用消息数加1。
  • (11):消息池的已用消息数减1。
  • (12):返回消息内容。

3. OS_Pend()函数

OS_Pend()函数将当前任务脱离就绪列表, 并根据用户指定的阻塞时间插入节拍列表和队列等待列表, 然后打开调度器,但不进行调度

void  OS_Pend (OS_PEND_DATA  *p_pend_data,  //待插入等待列表的元素
            OS_PEND_OBJ   *p_obj,        //等待的内核对象
            OS_STATE       pending_on,   //等待哪种对象内核
            OS_TICK        timeout)      //等待期限
{
    OS_PEND_LIST  *p_pend_list;
    OSTCBCurPtr->PendOn     = pending_on;             //资源不可用,开始等待
    OSTCBCurPtr->PendStatus = OS_STATUS_PEND_OK;             //正常等待中
    OS_TaskBlock(OSTCBCurPtr,timeout);       //阻塞当前运行任务,如果 timeout非0,把任务插入的节拍列表

    if (p_obj != (OS_PEND_OBJ *)0)                    //如果等待对象非空
    {
        p_pend_list             = &p_obj->PendList;    //获取对象的等待列表到p_pend_list
        p_pend_data->PendObjPtr = p_obj;              //保存要等待的对象
        OS_PendDataInit((OS_TCB       *)OSTCBCurPtr,         //初始化 p_pend_data(待插入等待列表)
                        (OS_PEND_DATA *)p_pend_data,
                        (OS_OBJ_QTY    )1);
        //按优先级将p_pend_data插入等待列表
        OS_PendListInsertPrio(p_pend_list,
                            p_pend_data);
    }
    else//如果等待对象为空
    {
        OSTCBCurPtr->PendDataTblEntries = (OS_OBJ_QTY    )0; //清零当前任务的等待域数据
        OSTCBCurPtr->PendDataTblPtr     = (OS_PEND_DATA *)0;
    }
#if OS_CFG_DBG_EN > 0u//如果启用了调试代码和变量
    OS_PendDbgNameAdd(p_obj,         //更新信号量的 DbgNamePtr元素为其等待
    OSTCBCurPtr);//列表中优先级最高的任务的名称。
#endif
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/520910.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Golang并发模型-Pipeline模型、Fan-in Fan-out模型

这段时间由于项目的需要&#xff0c;本人正在研究关于如何优雅的进行go的并发&#xff0c;以下是结合资料和视频的结果&#xff0c;文末会给出参考资料 Go语言的并发模型主要通过goroutine和channel实现&#xff0c;通过这个我们可以更有效地使用IO和CPU 这里我们围绕生成一个…

LRU的原理与实现(java)

介绍 LRU的英文全称为Least Recently Used&#xff0c;即最近最少使用。它是一种内存数据淘汰算法&#xff0c;当添加想要添加数据而内存不足时&#xff0c;它会优先将最近一段时间内使用最少的数据淘汰掉&#xff0c;再将数据添加进来。 原理 LRU的原理在介绍中就已经基本说…

linux基础篇:Linux操作系统vi编辑器讲解与常用操作

Linux操作系统vi编辑器讲解与常用操作 一、vi编辑器介绍 vi编辑器是一款功能强大的文本编辑器&#xff0c;广泛应用于Unix和类Unix系统。它是由Bill Joy在1976年开发的&#xff0c;后来演变成vim&#xff08;vi improved&#xff0c;即“改进版的vi”&#xff09;编辑器。vi编…

敏感信息泄露漏洞

法律声明 参与培训需要遵守国家法律法规&#xff0c;相关知识只做技术研究&#xff0c;请勿用于违法用途&#xff0c;造成任何后果自负与本人无关。 中华人民共和国网络安全法&#xff08;2017年6月1日起施行&#xff09; 第二十二条 任何个人和组织不得从事入侵他人网络、干扰…

【JAVASE】带你了解面向对象三大特性之一(继承)

✅作者简介&#xff1a;大家好&#xff0c;我是橘橙黄又青&#xff0c;一个想要与大家共同进步的男人&#x1f609;&#x1f609; &#x1f34e;个人主页&#xff1a;再无B&#xff5e;U&#xff5e;G-CSDN博客 1.继承 1.1 为什么需要继承 Java 中使用类对现实世界中实体来…

ubuntu-server部署hive-part2-安装hadoop

参照 https://blog.csdn.net/qq_41946216/article/details/134345137 操作系统版本&#xff1a;ubuntu-server-22.04.3 虚拟机&#xff1a;virtualbox7.0 安装hadoop ​​​​​​下载上传 下载地址 https://archive.apache.org/dist/hadoop/common/hadoop-3.3.4/ 以root用…

JDK 17 新特性实战,答案整理,最新面试题

JDK 17中的Pattern类增强了哪些功能&#xff1f; 1、新增asMatchPredicate方法&#xff1a; JDK 17的Pattern类新增了asMatchPredicate方法&#xff0c;可以将正则表达式编译为Predicate&#xff0c;方便用于过滤集合中的字符串。 2、增强了Unicode属性支持&#xff1a; JDK …

LLM推理参数(top_k,top_p, temperature, num_beams)

正常LLM做 next token predicate 时&#xff0c;对输出的 logits 做 softmax&#xff0c;选择概率最大的token。 num_beams &#xff1a;当我们设置 num_beams2 后&#xff0c;就使用了 beam search 的方法&#xff0c;每次不是只直接选择概率最大的 token&#xff0c;而是保留…

0基础确定要?进入it行业?

0基础如何进入IT行业&#xff1f; &#x1f31f;想进入IT行业&#xff1f;以下是一些对于0基础的人来说可行的步骤和建议&#xff01;&#x1f31f; "IT"是信息技术(Information Technology)的缩写&#xff0c;它指的是使用计算机、网络、软件和其他设备或系统来存…

数据安全之认识数据库审计系统

随着企业业务数据量的不断增长和数据存储的集中化&#xff0c;数据库成为企业的核心资产之一。然而&#xff0c;数据库面临着各种安全威胁&#xff0c;如SQL注入、权限滥用、数据泄露等。为了保障数据库的安全性和完整性&#xff0c;企业需要采取有效的审计措施来监控和记录数据…

spring源码解析-默认标签解析

spring 默认标签解析 parseDefaultElement处理流程 processBeanDefinition方法解析 processBeanDefinition时序图 元素解析 parseBeanDefinitionElement parseBeanDefinitionElement方法核心源码解析 创建GenericBeanDefinition实例对象 parseMetaElements parseConstructorAr…

平衡二叉树,红黑树,B树和B+树的区别及其应用场景

平衡二叉树 基础数据结构左右平衡高度差大于1会自旋每个节点记录一个数据 平衡二叉树&#xff08;AVL&#xff09; AVL树全称G.M. Adelson-Velsky和E.M. Landis&#xff0c;这是两个人的人名。 平衡二叉树也叫平衡二叉搜索树&#xff08;Self-balancing binary search tree…

通义灵码-ai编码

https://developer.aliyun.com/topic/lingma/activities/202403?taskCode14508&recordIdb1ef3ba27250a5818b1b6ffe418af658#/?utm_contentm_fission_1 「通义灵码 体验 AI 编码&#xff0c;开 AI 盲盒」

使用向量检索和rerank 在RAG数据集上实验评估hit_rate和mrr

文章目录 背景简介代码实现自定义检索器向量检索实验向量检索和rerank 实验 代码开源 背景 在前面部分 大模型生成RAG评估数据集并计算hit_rate 和 mrr 介绍了使用大模型生成RAG评估数据集与评估&#xff1b; 在 上文 使用到了BM25 关键词检索器。接下来&#xff0c;想利用向…

蓝桥杯 十一届C++A组 字符排序 21分(运行超时)

思路&#xff1a; 1. 此题考查的冒泡排序中的交换次数&#xff0c;其实就是考察当前数与后面的逆序对个数问题。而为了最大利用位数&#xff0c;应当使每一位都不小于后面的字符&#xff0c;否则会造成一次逆序对的浪费&#xff08;贪心&#xff0c;为了使总位数最少&#xff…

springBoot--阿里云短信验证

阿里云短信验证 前言阿里云短信服务免费领取100条短信服务1、开通短信服务2、申请签名3、申请模板4、通过子用户获取账号的AccessKey ID 和AccessKey Secret5、使用教程 前言 在我们平时登录中短信验证吗验证在当今是必不可少的&#xff0c;下面是基于阿里云开发的短信验证操作…

达梦数据库安装与实例创建:图形化方式

达梦数据库安装与实例创建&#xff1a;图形化方式 准备工作数据库安装与卸载安装数据库卸载数据库 实例创建与删除创建实例删除实例 准备工作 查看操作系统信息&#xff1a;Linux内核不能低于2.6。 [rootlocalhost ~]# cat /proc/version Linux version 4.19.90-24.4.v2101.k…

PyTorch|Dataset与DataLoader使用、构建自定义数据集

文章目录 一、Dataset与DataLoader二、自定义Dataset类&#xff08;一&#xff09;\_\_init\_\_函数&#xff08;二&#xff09;\_\_len\_\_函数&#xff08;三&#xff09;\_\_getitem\_\函数&#xff08;四&#xff09;全部代码 三、将单个样本组成minibatch&#xff08;Data…

信息论基础:串联信道

串联信道 大学时候看过一期湖南卫视《快乐大本营》&#xff0c;那时候的主持人是何炅和李湘。节目的一个环节是邀请五名观众上台做猜谜游戏。五人带上耳机&#xff0c;坐在一排椅子上&#xff0c;两两中间隔着挡板&#xff0c;好像并排在一起上厕所。李湘把一部电影的名字写在…

Redis集群三种模式

一、Redis集群的三种模式 Redis有三种模式&#xff0c;分别是主从复制、哨兵模式、cluster 主从复制:主从复制是高可用Redis的基础&#xff0c;哨兵和集群都是在主从复制基础上实现高可用的。主从复制主要实现了数据的多机备份&#xff0c;以及对于读操作的负载均衡和简单的故障…