uC/OS-II源码解析(os_mutex.c)

最新推荐文章于 2021-05-27 18:18:15 发布
最新推荐文章于 2021-05-27 18:18:15 发布
阅读量870 收藏
点赞数
文章标签： ucos 源码 解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010650845/article/details/72152635
版权 
/*
** ver   : 2.52
** file  : os_mutex.c
** brief : 互斥型信号量相关函数 C 文件
**
** mutex : 互斥型信号量
** PIP   : 优先级继承优先级
*/

#ifndef  OS_MASTER_FILE
#include "includes.h"                   /* 包含头文件    */
#endif

/*
******************************************************************************
*                                            逻辑常量
******************************************************************************
*/

#define  OS_MUTEX_KEEP_LOWER_8   0x00FF /* 低八位 : 标注mutex是否有效    */
#define  OS_MUTEX_KEEP_UPPER_8   0xFF00 /* 高八位 : 记录优先级继承优先级 */

#define  OS_MUTEX_AVAILABLE      0x00FF /* mutex有效                     */


#if OS_MUTEX_EN > 0
/*
*******************************************************************************
*                                  无等待的获取mutex
*
* brief  : 该函数用于无等待的请求mutex.
*
* pevent : 指向事件控制块的指针
*
* err    : 指向错误代码的指针，可能取值:
*            OS_NO_ERR          成功
*            OS_ERR_EVENT_TYPE  错误的事件类型
*            OS_ERR_PEVENT_NULL 无效的事件控制块指针
*            OS_ERR_PEND_ISR    不能在中断内请求
*
* Returns    : == 1       mutex有效
*              == 0       a) mutex无效
*                         b) 错误的事件控制块指针
*                         c) 中断内调用
*
**************************************************************************************
*/

#if OS_MUTEX_ACCEPT_EN > 0
INT8U  OSMutexAccept (OS_EVENT *pevent, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3                            
    OS_CPU_SR  cpu_sr;
#endif    


    if (OSIntNesting > 0) {                            /* 不允许在中断内调用      */
        *err = OS_ERR_PEND_ISR;
        return (0);
    }
#if OS_ARG_CHK_EN > 0
    if (pevent == (OS_EVENT *)0) {                     /* 无效的事件控制块指针    */
        *err = OS_ERR_PEVENT_NULL;
        return (0);
    }
    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {  /* 错误的事件类型          */
        *err = OS_ERR_EVENT_TYPE;
        return (0);
    }
#endif                                                     
    OS_ENTER_CRITICAL();                               
    if ((pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {     
        pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;   /* 记录优先级  */
        pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;   
        pevent->OSEventPtr  = (void *)OSTCBCur;        /*  链接TCB    */
        OS_EXIT_CRITICAL();
        *err = OS_NO_ERR;
        return (1);
    }
    OS_EXIT_CRITICAL();
    *err = OS_NO_ERR;
    return (0);
}
#endif                                                     

/*$PAGE*/
/*
**************************************************************************************
*                                  创建 Mutex 
*
* breif : 该函数用于创建mutex.
*
* prio  : PIP
*
* err   : 指向错误代码的指针，可能取值:
*           OS_NO_ERR           成功.
*           OS_ERR_CREATE_ISR   不允许在中断中创建mutex
*           OS_PRIO_EXIST       PIP的任务已经存在
*           OS_ERR_PEVENT_NULL  无空余事件控制块
*           OS_PRIO_INVALID     无效优先级
*
* Note(s)    : 1) '.OSEventCnt' 低八位为0xFF表示mutex有效，否则为占用资源的任务优先级
*              2) '.OSEventCnt' 高八位记录PIP
***************************************************************************************
*/

OS_EVENT  *OSMutexCreate (INT8U prio, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3                              
    OS_CPU_SR  cpu_sr;
#endif    
    OS_EVENT  *pevent;


    if (OSIntNesting > 0) {                   /* 不允许中断创建mutex      */
        *err = OS_ERR_CREATE_ISR;            
        return ((OS_EVENT *)0);
    }
#if OS_ARG_CHK_EN > 0
    if (prio >= OS_LOWEST_PRIO) {             /* 无效的优先级             */
        *err = OS_PRIO_INVALID;
        return ((OS_EVENT *)0);
    }
#endif
    OS_ENTER_CRITICAL();
    if (OSTCBPrioTbl[prio] != (OS_TCB *)0) {  /* PIP任务已经存在          */
        OS_EXIT_CRITICAL();                   
        *err = OS_PRIO_EXIST;                              
        return ((OS_EVENT *)0);                            
    }
    OSTCBPrioTbl[prio] = (OS_TCB *)1;         /* 占用 OSTCBPrioTbl[prio]   */
    pevent             = OSEventFreeList;     /* 获取事件控制块            */
    if (pevent == (OS_EVENT *)0) {            /* 无剩余事件控制块可用      */
        OSTCBPrioTbl[prio] = (OS_TCB *)0;     /* 释放 OSTCBPrioTbl[prio]   */
        OS_EXIT_CRITICAL();
        *err               = OS_ERR_PEVENT_NULL;                   
        return (pevent);
    }
    OSEventFreeList     = (OS_EVENT *)OSEventFreeList->OSEventPtr;/* 调整ECB链表 */
    OS_EXIT_CRITICAL();
    pevent->OSEventType = OS_EVENT_TYPE_MUTEX;
    pevent->OSEventCnt  = (prio << 8) | OS_MUTEX_AVAILABLE;/* PIP|资源有效       */
    pevent->OSEventPtr  = (void *)0;                       /* 无任务等待         */
    OS_EventWaitListInit(pevent);
    *err                = OS_NO_ERR;
    return (pevent);
}

/*$PAGE*/
/*
**********************************************************************************
*                                          删除 Mutex
*
* brief  : 该函数用删除 mutex
*
* pevent : 指向事件控制块的指针
*
* opt    : 删除选项
*            opt == OS_DEL_NO_PEND   无任务等待时删除
*            opt == OS_DEL_ALWAYS    删除，如有任务等待则置为就绪
*                                                   
*
* err    : 指向错误代码的指针，可能取值:
*            OS_NO_ERR               成功
*            OS_ERR_DEL_ISR          不允许中断中删除
*            OS_ERR_INVALID_OPT      无效的删除选项
*            OS_ERR_TASK_WAITING     有任务等待
*            OS_ERR_EVENT_TYPE       错误的事件类型
*            OS_ERR_PEVENT_NULL      无效的事件控制块指针
*
**********************************************************************************
*/

#if OS_MUTEX_DEL_EN
OS_EVENT  *OSMutexDel (OS_EVENT *pevent, INT8U opt, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3                      
    OS_CPU_SR  cpu_sr;
#endif    
    BOOLEAN    tasks_waiting;
    INT8U      pip;


    if (OSIntNesting > 0) {                  /* 中断中不能删除mutex    */
        *err = OS_ERR_DEL_ISR;           
        return (pevent);
    }
#if OS_ARG_CHK_EN > 0
    if (pevent == (OS_EVENT *)0) {           /* 无效的事件控制块指针   */
        *err = OS_ERR_PEVENT_NULL;
        return ((OS_EVENT *)0);
    }
    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {      /* 无效的事件类型      */
        *err = OS_ERR_EVENT_TYPE;
        return (pevent);
    }
#endif
    OS_ENTER_CRITICAL();
    if (pevent->OSEventGrp != 0x00) {                      /* 是否有任务在等待mutex*/
        tasks_waiting = TRUE;                               
    } else {
        tasks_waiting = FALSE;                            
    }
    switch (opt) {
        case OS_DEL_NO_PEND:                               /* 无任务等待删除mutex*/
             if (tasks_waiting == FALSE) {
                 pip                 = (INT8U)(pevent->OSEventCnt >> 8);
                 OSTCBPrioTbl[pip]   = (OS_TCB *)0;/* 释放PIP,创建信号量时占用   */
                 pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
                 pevent->OSEventPtr  = OSEventFreeList;    /* 返还事件控制块     */
                 OSEventFreeList     = pevent;
                 OS_EXIT_CRITICAL();
                 *err = OS_NO_ERR;
                 return ((OS_EVENT *)0);                             
             } else {                                      /* 有任务等待         */
                 OS_EXIT_CRITICAL();
                 *err = OS_ERR_TASK_WAITING;
                 return (pevent);
             }

        case OS_DEL_ALWAYS:                                /* 无条件删除         */
             while (pevent->OSEventGrp != 0x00) {          /* 就绪所有等待任务   */
                 OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);
             }
             pip                 = (INT8U)(pevent->OSEventCnt >> 8);
             OSTCBPrioTbl[pip]   = (OS_TCB *)0;            /* 释放PIP            */
             pevent->OSEventType = OS_EVENT_TYPE_UNUSED;
             pevent->OSEventPtr  = OSEventFreeList;        /* 返还事件控制块     */
             OSEventFreeList     = pevent;              
             OS_EXIT_CRITICAL();
             if (tasks_waiting == TRUE) {                  
                 OS_Sched();                               /* 任务调度           */
             }
             *err = OS_NO_ERR;
             return ((OS_EVENT *)0);                    

        default:
             OS_EXIT_CRITICAL();
             *err = OS_ERR_INVALID_OPT;
             return (pevent);
    }
}
#endif

/*$PAGE*/
/*
*******************************************************************************
*                                  请求mutex
*
* brief   : 该函数用来请求mutex
*
* pevent  : 指向事件控制块的指针
*
* timeout : 等待超时
*
* err     : 指向错误代码的指针，可能取值:
*             OS_NO_ERR          成功
*             OS_TIMEOUT         超时
*             OS_ERR_EVENT_TYPE  错误的事件类型
*             OS_ERR_PEVENT_NULL 无效的事件控制块指针
*             OS_ERR_PEND_ISR    不允许在中断中请求 
*
* Note(s)    : 1) 拥有mutex的任务，不能在请求任何其他mutex 
*              2) 不一定非要改变任务的优先级
********************************************************************************
*/
void  OSMutexPend (OS_EVENT *pevent, INT16U timeout, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3                              
    OS_CPU_SR  cpu_sr;
#endif    
    INT8U      pip;                  /* 优先级继承优先级(PIP)      */
    INT8U      mprio;                /* 当前占用mutex的任务优先级  */
    BOOLEAN    rdy;                  /* 任务就绪标志               */
    OS_TCB    *ptcb;


    if (OSIntNesting > 0) {          /* 中断内不能请求mutex        */
        *err = OS_ERR_PEND_ISR;     
        return;
    }
#if OS_ARG_CHK_EN > 0
    if (pevent == (OS_EVENT *)0) {   /* 无效的事件控制块指针       */
        *err = OS_ERR_PEVENT_NULL;
        return;
    }
    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {/* 无效的事件类型 */
        *err = OS_ERR_EVENT_TYPE;
        return;
    }
#endif
    OS_ENTER_CRITICAL();                                   
    if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) {
        pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;       /* mutex有效        */
        pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;         /* 记录优先级       */
        pevent->OSEventPtr  = (void *)OSTCBCur;            /* 指向任务控制块   */
        OS_EXIT_CRITICAL();
        *err  = OS_NO_ERR;
        return;        
    }
    /* 获取优先级继承优先级 */
    pip   = (INT8U)(pevent->OSEventCnt >> 8);     
    /* 获取占用mutex任务的优先级 */
    mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); 
    /* 获取占用mutex任务的控制块 */
    ptcb  = (OS_TCB *)(pevent->OSEventPtr);   
     /* 是否需要提升占用任务优先级*/
    if (ptcb->OSTCBPrio != pip && mprio > OSTCBCur->OSTCBPrio) { 
        if ((OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) != 0x00) { /* 查看是否就绪   */
                                                                  /*  取消就绪      */                                  
            if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0x00) {
                OSRdyGrp &= ~ptcb->OSTCBBitY;
            }
            rdy = TRUE;
        } else {
            rdy = FALSE;                                        
        }
        ptcb->OSTCBPrio         = pip;                     /* 修改优先级 */
        ptcb->OSTCBY            = ptcb->OSTCBPrio >> 3;    /* 预计算     */
        ptcb->OSTCBBitY         = OSMapTbl[ptcb->OSTCBY];
        ptcb->OSTCBX            = ptcb->OSTCBPrio & 0x07;
        ptcb->OSTCBBitX         = OSMapTbl[ptcb->OSTCBX];
        if (rdy == TRUE) {                                 /* 新优先级就绪 */
            OSRdyGrp               |= ptcb->OSTCBBitY;     
            OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        }
        OSTCBPrioTbl[pip]       = (OS_TCB *)ptcb;
    }
    OSTCBCur->OSTCBStat |= OS_STAT_MUTEX;             /* 等待mutex状态  */
    OSTCBCur->OSTCBDly   = timeout;                   /* 记录等到超时   */
    OS_EventTaskWait(pevent);                         /* 任务进入等待   */
    OS_EXIT_CRITICAL();
    OS_Sched();                                       /* 任务调度       */
    OS_ENTER_CRITICAL();
    if (OSTCBCur->OSTCBStat & OS_STAT_MUTEX) {        /* 查看是否超时继续运行 */
        OS_EventTO(pevent);
        OS_EXIT_CRITICAL();
        *err = OS_TIMEOUT;                            /* 超时进入就绪   */
        return;
    }
    OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;
    OS_EXIT_CRITICAL();
    *err = OS_NO_ERR;
}
/*$PAGE*/
/*
******************************************************************************
*                                  释放mutex
*
* brief  : 该函数用于释放 mutex
*
* pevent : 指向事件控制块的指针
*
* Returns    : OS_NO_ERR               成功
*              OS_ERR_EVENT_TYPE       错误的事件类型
*              OS_ERR_PEVENT_NULL      无效的事件控制块指针
*              OS_ERR_POST_ISR         不能自中断中释放mutex
*              OS_ERR_NOT_MUTEX_OWNER  释放mutex的任务并没有占用mutex
********************************************************************************
*/

INT8U  OSMutexPost (OS_EVENT *pevent)
{
#if OS_CRITICAL_METHOD == 3                          
    OS_CPU_SR  cpu_sr;
#endif    
    INT8U      pip;                             /* 优先级继承优先级       */
    INT8U      prio;


    if (OSIntNesting > 0) {                     /* 中断内不允许释放mutex  */
        return (OS_ERR_POST_ISR);                              
    }
#if OS_ARG_CHK_EN > 0
    if (pevent == (OS_EVENT *)0) {              /* 无效的事件控制块指针   */
        return (OS_ERR_PEVENT_NULL);
    }
    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) { /* 无效的事件类型   */
        return (OS_ERR_EVENT_TYPE);
    }                                                 
#endif
    OS_ENTER_CRITICAL();
    pip  = (INT8U)(pevent->OSEventCnt >> 8);          /* 获取PIP    */
    /* 获取占用mutex的任务优先级  */
    prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);  
    if (OSTCBCur->OSTCBPrio != pip && 
        OSTCBCur->OSTCBPrio != prio) {/* 当前任务未占有mutex  */
        OS_EXIT_CRITICAL();
        return (OS_ERR_NOT_MUTEX_OWNER);
    }
    if (OSTCBCur->OSTCBPrio == pip) { /* 优先级被提升 */

        /* 移除PIP的就绪 */                                      
        if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
            OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
        }
        OSTCBCur->OSTCBPrio         = prio;      /* 修改为原来优先级 */
        OSTCBCur->OSTCBY            = prio >> 3; /* 预运算           */
        OSTCBCur->OSTCBBitY         = OSMapTbl[OSTCBCur->OSTCBY];
        OSTCBCur->OSTCBX            = prio & 0x07;
        OSTCBCur->OSTCBBitX         = OSMapTbl[OSTCBCur->OSTCBX];
        OSRdyGrp                   |= OSTCBCur->OSTCBBitY;/* 置就绪  */
        OSRdyTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;
        OSTCBPrioTbl[prio]          = (OS_TCB *)OSTCBCur; 
    }
    OSTCBPrioTbl[pip] = (OS_TCB *)1;     /* 占用OSTCBPrioTbl[pip] 请求mutex时用 */
    if (pevent->OSEventGrp != 0x00) {                 /* 是否有任务在等待mutex  */
                                                      /* 等待任务进入就绪       */
        prio                = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX);
        pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;  /* 记录优先级             */
        pevent->OSEventCnt |= prio;
        pevent->OSEventPtr  = OSTCBPrioTbl[prio];     /* 链接任务控制块         */
        OS_EXIT_CRITICAL();
        OS_Sched();                                   /* 任务调度               */
        return (OS_NO_ERR);
    }
    pevent->OSEventCnt |= OS_MUTEX_AVAILABLE;         /* 使mutex有效            */
    pevent->OSEventPtr  = (void *)0;
    OS_EXIT_CRITICAL();
    return (OS_NO_ERR);
}
/*$PAGE*/
/*
*******************************************************************************
*                                     查询mutex
*
* brief  : 该函数用于查询mutex
*
* pevent : 指向事件控制块的指针
*
* pdata  : 保存mutex信息的数据结构指针
*
* Returns    : OS_NO_ERR            成功
*              OS_ERR_QUERY_ISR     不能再中断中请求
*              OS_ERR_PEVENT_NULL   无效的事件控制块指针
*              OS_ERR_EVENT_TYPE    错误的事件类型
********************************************************************************
*/

#if OS_MUTEX_QUERY_EN > 0
INT8U  OSMutexQuery (OS_EVENT *pevent, OS_MUTEX_DATA *pdata)
{
#if OS_CRITICAL_METHOD == 3                      
    OS_CPU_SR  cpu_sr;
#endif    
    INT8U     *psrc;
    INT8U     *pdest;


    if (OSIntNesting > 0) {                          /* 不允许在中断内调用    */
        return (OS_ERR_QUERY_ISR);                   
    }
#if OS_ARG_CHK_EN > 0
    if (pevent == (OS_EVENT *)0) {                   /* 无效的事件控制块指针  */
        return (OS_ERR_PEVENT_NULL);
    }
    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {/* 错误的事件类型        */
        return (OS_ERR_EVENT_TYPE);
    }
#endif
    OS_ENTER_CRITICAL();
    pdata->OSMutexPIP  = (INT8U)(pevent->OSEventCnt >> 8);/* 优先级继承优先级 */
    /* 占有mutex的任务优先级，若为0xFF则为被占用mutex有效 */
    pdata->OSOwnerPrio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8);
    if (pdata->OSOwnerPrio == 0xFF) {
        pdata->OSValue = 1; /* mutex有效 */
    } else {
        pdata->OSValue = 0; /* mutex无效 */
    }
    pdata->OSEventGrp  = pevent->OSEventGrp;     /* 复制等待任务链表            */
    psrc               = &pevent->OSEventTbl[0];
    pdest              = &pdata->OSEventTbl[0];
#if OS_EVENT_TBL_SIZE > 0
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 1
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 2
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 3
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 4
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 5
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 6
    *pdest++           = *psrc++;
#endif

#if OS_EVENT_TBL_SIZE > 7
    *pdest             = *psrc;
#endif
    OS_EXIT_CRITICAL();
    return (OS_NO_ERR);
}
#endif                                                     
#endif
DingUXiu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
uCOSII.rar_Os_core.c_UCOS 2.52_Ucos-ii 2.52_os_sem.c_ucosii stm3
09-24
UCOS 2.52源代码，包括OS_CORE.C、OS_FLAG.C、OS_MBOX.C、OS_MEM.C、OS_MUTEX.C、OS_Q.C、OS_SEM.C、OS_TASK.C、OS_TIME.C和uCOS_II.H。
os_mutex.c（全）
allein_STR的博客
02-19 3131
无等待地获取互斥型信号量 OSMutexAccept (OS_EVENT  *pevent,INT8U  *perr):创建互斥型信号量OS_EVENT  *OSMutexCreate (INT8U   prio,INT8U  *perr)删除信号量OS_EVENT  *OSMutexDel (OS_EVENT  *pevent,INT8U  opt,INT8U  *perr)等待互斥型信号量vo...
（10）从1开始写一个操作系统
andylauren的专栏
09-23 531
第十章 任务间同步和通信 Inter-Task Communication，任务间通信 多任务就会涉及到任务间共享资源的互斥操作和任务间通信。我们所需要完成的是能够提供这些功能的函数，来让用户更好的实现任务间同步和通信。 我们将会实现互斥锁、信号量、消息队列以及事件标志。 优先级翻转 谈到任务间同步的机制就会涉及到优先级翻转的问题。 首先说一下什么是优先级翻转。 简单从字面上...
os_mutex.c
echo_bright_的博客
09-09 2547
定位到uCOS-II/Source/os_mutex.c，该文件是互斥型信号量的相关操作函数。互斥型信号量也就是互斥锁Mutex，是一个二值(0/1)信号量。在操作共享资源时，使用Mutex可以保证满足互斥条件。1. 非阻塞的获取互斥型信号量函数OSMutexAccept()  OSMutexAccept()用于检测Mutex以判断是否可用，若资源不可用，调用此函数不会使得所在任务被挂起。//允许使
uCOS-II互斥型信号量的相关操作函数
nihao_2014的博客
02-27 1137
定位到uCOS-II/Source/os_mutex.c，该文件是互斥型信号量的相关操作函数。互斥型信号量也就是互斥锁Mutex，是一个二值(0/1)信号量。在操作共享资源时，使用Mutex可以保证满足互斥条件。 1. 非阻塞的获取互斥型信号量函数OSMutexAccept()   OSMutexAccept()用于检测Mutex以判断是否可用，若资源不可用，调用此函数不会使得所在任务被挂起。 //允许使用os中的Mutex #if OS_MUTEX_ACCEPT_EN > 0u BOOLEAN
OS_MUTEX.C
用法之妙，存乎一心。
11-19 1794
1 /* 2 ************************************************************************************************* 3 * uC/OS-II实时控制内核 4 * 互斥型信号
create-mutex.zip_Mutex_mutex in ucos_uCOS mutex_ucos mutex
09-22
ucos-ii中互斥信号mutex建立源码
lock_mutex.rar_Linux/Unix编程_Unix_Linux_
08-12
演示了linux中的互斥锁机制，用gcc编译后运行
UCOS-2.52.rar_UCOS 2.52_os_ucos-core
09-14
ucos2.52内核源码包括OS_CORE.C、OS_FLAG.C、OS_MBOX.C、OS_MEM.C、OS_MUTEX.C、OS_Q.C、OS_SEM.C、OS_TASK.C、OS_TIME.C和uCOS_II.H
mtx-tutorial.txt_synchronization_tutorial_Mutex_atomic_operation
09-30
a tutorial on how to implement and optimize mutexes with gcc inline assembly
thread_mutex.c
12-10
从实践中学Linux应用开发之在信号量的基础上增加互斥锁的功能，实现原本独立与无序的多个线程按顺序执行。
thread_mutex.c 文件
07-20
多线程之间的同步与互斥，详情看博客：http://blog.csdn.net/mybelief321/article/details/9390707
FeedDogSys_v3.0_mutex.zip
04-12
通过stm32实现的，在UCOS系统上面做的，完成了界面、触摸屏、录音、舵机等，整合到一起 添加了图片，按钮，表格之类的控件，多任务实现
Mutex_Critical.rar_MUTEX算法_event_mfc 控制 界面_mfc中控_界面线程
09-19
要进行互斥控制，则必须用到Event、Mutex、CrititicalSection、Semaphore等互斥控制量。这个例子可以使用 Event、Mutex、CrititicalSection，你可以根据提示修改代码使用其中的一种互斥量进行测试。 我所写的例子...
Mutex.zip_Linux/Unix编程_C/C++_
08-10
封装了Linux下的互斥锁、读写锁、条件锁以及防止死锁的策略
Nginx的accept_mutex配置分析
weixin_30347335的博客
01-08 421
让我们看看accept_mutex的意义：当一个新连接到达时，如果激活了accept_mutex，那么多个Worker将以串行方式来处理，其中有一个Worker会被唤醒，其他的Worker继续保持休眠状态；如果没有激活accept_mutex，那么所有的Worker都会被唤醒，不过只有一个Worker能获取新连接，其它的Worker会重新进入休眠状态，这就是「惊群问题」。 Nginx缺...
uc/os-II 分析（8）---互斥型信号量
lygweifeng的博客
11-13 678
互斥型信号量  互斥型信号量是一个二值信号量，可以使任务以独占方式使用共享，他可以独占方式使用共享资源。 互斥型信号量会出现任务优先级反转的问题。 1.优先级反转   在可剥夺型内核中，当任务以独占方式使用共享资源时，会出现低优先级任务先于高优先级 任务而被运行现象，这种现象叫做任务优先级反转。  出现优先级反转现象：  是因为一个优先级别较低的任务在获得了信号量使用共享资源期间，被具
【 uC/OS II 】uC/OS II 源代码阅读（os_mutex.c）互斥信号量
风一样的少年
05-27 344
前言 这个关于互斥信号量的代码，最核心的就是优先级反转。先说一下优先级反转吧。 在创建互斥信号量的时候，需要传入反转的优先级，也就是当发生优先级反转的时候，将当前拥有信号量的任务的优先级提升为反转的优先级。 优先级反转情景： 假设有两个任务A，任务B，任务A的优先级小于任务B。此时A拥有互斥信号量，但是此时B来了，B的优先级高于A，但是因为B也需要互斥信号量，所以按照常理来说，B应该等待信号量，但是这是一个RTOS，本身就是基于优先级抢占的，所以此时为了缩短B的等待时间，需要B任务来主动的将A任务的优先级提
___pthread_mutex_lock (mutex=0x0) at ./nptl/pthread_mutex_lock.c:80 #1 0x0000555555557095 in __gthread_mutex_lock (__mutex=0x0) at /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h:749 #2 std::mutex::lock (this=0x0) at /usr/include/c++/11/bits/std_mutex.h:100 #3 std::lock_guard<std::mutex>::lock_guard (__m=..., this=<synthetic pointer>) at /usr/include/c++/11/bits/std_mutex.h:229 #4 freciplex::fileoperater::delete_ (this=this@entry=0x0, path="/home/freciplex/桌面/filesystem/log/test.txt")
最新发布
07-12
这个函数在执行过程中使用了互斥锁来保护共享资源，具体是通过调用`std::lock_guard<std::mutex>`来实现的。不过，根据代码中的信息，互斥锁（mutex）的指针为0x0，即空指针，这可能会导致程序出现问题。正确的做法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DingUXiu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值