OSQueue用法

最新推荐文章于 2023-10-15 12:37:01 发布
最新推荐文章于 2023-10-15 12:37:01 发布
阅读量1.1k 收藏
点赞数
分类专栏： dss
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunxiaopengsun/article/details/54668478
版权 

#ifndef _OSQUEUE_H_
#define _OSQUEUE_H_

#include "MyAssert.h"
#include "OSHeaders.h"
#include "OSMutex.h"
#include "OSCond.h"
#include "OSThread.h"

#define OSQUEUETESTING 0

class OSQueue;

class OSQueueElem {
    public:
        OSQueueElem(void* enclosingObject = NULL) : fNext(NULL), fPrev(NULL), fQueue(NULL),
                                                    fEnclosingObject(enclosingObject) {}
        virtual ~OSQueueElem() { Assert(fQueue == NULL); }

        Bool16 IsMember(const OSQueue& queue) { return (&queue == fQueue); }
        Bool16 IsMemberOfAnyQueue()     { return fQueue != NULL; }
        void* GetEnclosingObject()  { return fEnclosingObject; }
        void SetEnclosingObject(void* obj) { fEnclosingObject = obj; }

        OSQueueElem* Next() { return fNext; }
        OSQueueElem* Prev() { return fPrev; }
        OSQueue* InQueue()  { return fQueue; }
        inline void Remove();

    private:

        OSQueueElem*    fNext;
        OSQueueElem*    fPrev;
		//每个元素内部通过队列指针能够判断出该元素是否是该队列中的元素，同时也可以通过该元素直接从队列中将自己删除
        OSQueue *       fQueue;
        void*           fEnclosingObject;

        friend class    OSQueue;
};

class OSQueue {
    public:
        OSQueue();
        ~OSQueue() {}

		//进队
        void            EnQueue(OSQueueElem* object);
		//出队
        OSQueueElem*    DeQueue();

		//获取队头元素
        OSQueueElem*    GetHead() { if (fLength > 0) return fSentinel.fPrev; return NULL; }
		//获取队尾元素
        OSQueueElem*    GetTail() { if (fLength > 0) return fSentinel.fNext; return NULL; }
		//获取队列长度
        UInt32          GetLength() { return fLength; }
        //删除某个元素
        void            Remove(OSQueueElem* object);

#if OSQUEUETESTING
        static Bool16       Test();
#endif

    protected:
		//双向链表头节点，不存储任何元素，使插入删除元素方便
        OSQueueElem     fSentinel;
        UInt32          fLength;
};

class OSQueueIter
{
    public:
		//默认让fCurrentElemP指向队列头
        OSQueueIter(OSQueue* inQueue) : fQueueP(inQueue), fCurrentElemP(inQueue->GetHead()) {}
		//让fCurrentElemP指向startElemP，startElemP必须是队列中的元素，如果不是则让fCurrentElemP指向空
        OSQueueIter(OSQueue* inQueue, OSQueueElem* startElemP ) : fQueueP(inQueue)
            {
                if ( startElemP )
                {   Assert( startElemP->IsMember(*inQueue ) );
                    fCurrentElemP = startElemP;
                
                }
                else
                    fCurrentElemP = NULL;
            }
        ~OSQueueIter() {}
        //重置当前元素位置，使其为队列头
        void            Reset() { fCurrentElemP = fQueueP->GetHead(); }
        //获取当前元素
        OSQueueElem*    GetCurrent() { return fCurrentElemP; }
		//fCurrentElemP指向下一个元素
        void            Next();
        //队列空了
        Bool16          IsDone() { return fCurrentElemP == NULL; }
        
    private:
		//队列指针
        OSQueue*        fQueueP;
		//队列指向的当前元素
        OSQueueElem*    fCurrentElemP;
};

class OSQueue_Blocking
{
    public:
        OSQueue_Blocking() {}
        ~OSQueue_Blocking() {}
        //出队列，如果队列没有元素，则阻塞，直到调用EnQueue发出信号后，才解除阻塞
        OSQueueElem*    DeQueueBlocking(OSThread* inCurThread, SInt32 inTimeoutInMilSecs);
		//出队列，不会阻塞，如果队列没有元素，则直接返回空
        OSQueueElem*    DeQueue();//will not block
		//每次入队列的时候，都会调用Signal发出信号
        void            EnQueue(OSQueueElem* obj);
        
        OSCond*         GetCond()   { return &fCond; }
        OSQueue*        GetQueue()  { return &fQueue; }
        
    private:

        OSCond              fCond;
        OSMutex             fMutex;
        OSQueue             fQueue;
};


void    OSQueueElem::Remove()
{
    if (fQueue != NULL)
        fQueue->Remove(this);
}
#endif //_OSQUEUE_H_




#include "OSQueue.h"


OSQueue::OSQueue() : fLength(0)
{
    fSentinel.fNext = &fSentinel;
    fSentinel.fPrev = &fSentinel;
}

void OSQueue::EnQueue(OSQueueElem* elem)
{
    Assert(elem != NULL);
    if (elem->fQueue == this)
        return;
    Assert(elem->fQueue == NULL);
    elem->fNext = fSentinel.fNext;
    elem->fPrev = &fSentinel;
    elem->fQueue = this;
    fSentinel.fNext->fPrev = elem;
    fSentinel.fNext = elem;
    fLength++;
}

OSQueueElem* OSQueue::DeQueue()
{
    if (fLength > 0)
    {
        OSQueueElem* elem = fSentinel.fPrev;
        Assert(fSentinel.fPrev != &fSentinel);
        elem->fPrev->fNext = &fSentinel;
        fSentinel.fPrev = elem->fPrev;
        elem->fQueue = NULL;
        fLength--;
        return elem;
    }
    else
        return NULL;
}

void OSQueue::Remove(OSQueueElem* elem)
{
    Assert(elem != NULL);
    Assert(elem != &fSentinel);
    
    if (elem->fQueue == this)
    {
        elem->fNext->fPrev = elem->fPrev;
        elem->fPrev->fNext = elem->fNext;
        elem->fQueue = NULL;
        fLength--;
    }
}

#if OSQUEUETESTING
Bool16 OSQueue::Test()
{
    OSQueue theVictim;
    void *x = (void*)1;
    OSQueueElem theElem1(x);
    x = (void*)2;
    OSQueueElem theElem2(x);
    x = (void*)3;
    OSQueueElem theElem3(x);
    
    if (theVictim.GetHead() != NULL)
        return false;
    if (theVictim.GetTail() != NULL)
        return false;
    
    theVictim.EnQueue(&theElem1);
    if (theVictim.GetHead() != &theElem1)
        return false;
    if (theVictim.GetTail() != &theElem1)
        return false;
    
    OSQueueElem* theElem = theVictim.DeQueue();
    if (theElem != &theElem1)
        return false;
    
    if (theVictim.GetHead() != NULL)
        return false;
    if (theVictim.GetTail() != NULL)
        return false;
    
    theVictim.EnQueue(&theElem1);
    theVictim.EnQueue(&theElem2);

    if (theVictim.GetHead() != &theElem1)
        return false;
    if (theVictim.GetTail() != &theElem2)
        return false;
        
    theElem = theVictim.DeQueue();
    if (theElem != &theElem1)
        return false;

    if (theVictim.GetHead() != &theElem2)
        return false;
    if (theVictim.GetTail() != &theElem2)
        return false;

    theElem = theVictim.DeQueue();
    if (theElem != &theElem2)
        return false;

    theVictim.EnQueue(&theElem1);
    theVictim.EnQueue(&theElem2);
    theVictim.EnQueue(&theElem3);

    if (theVictim.GetHead() != &theElem1)
        return false;
    if (theVictim.GetTail() != &theElem3)
        return false;

    theElem = theVictim.DeQueue();
    if (theElem != &theElem1)
        return false;

    if (theVictim.GetHead() != &theElem2)
        return false;
    if (theVictim.GetTail() != &theElem3)
        return false;

    theElem = theVictim.DeQueue();
    if (theElem != &theElem2)
        return false;

    if (theVictim.GetHead() != &theElem3)
        return false;
    if (theVictim.GetTail() != &theElem3)
        return false;

    theElem = theVictim.DeQueue();
    if (theElem != &theElem3)
        return false;

    theVictim.EnQueue(&theElem1);
    theVictim.EnQueue(&theElem2);
    theVictim.EnQueue(&theElem3);
    
    OSQueueIter theIterVictim(&theVictim);
    if (theIterVictim.IsDone())
        return false;
    if (theIterVictim.GetCurrent() != &theElem3)
        return false;
    theIterVictim.Next();
    if (theIterVictim.IsDone())
        return false;
    if (theIterVictim.GetCurrent() != &theElem2)
        return false;
    theIterVictim.Next();
    if (theIterVictim.IsDone())
        return false;
    if (theIterVictim.GetCurrent() != &theElem1)
        return false;
    theIterVictim.Next();
    if (!theIterVictim.IsDone())
        return false;
    if (theIterVictim.GetCurrent() != NULL)
        return false;

    theVictim.Remove(&theElem1);

    if (theVictim.GetHead() != &theElem2)
        return false;
    if (theVictim.GetTail() != &theElem3)
        return false;

    theVictim.Remove(&theElem1);

    if (theVictim.GetHead() != &theElem2)
        return false;
    if (theVictim.GetTail() != &theElem3)
        return false;

    theVictim.Remove(&theElem3);

    if (theVictim.GetHead() != &theElem2)
        return false;
    if (theVictim.GetTail() != &theElem2)
        return false;

    return true;
}   
#endif



void OSQueueIter::Next()
{
    if (fCurrentElemP == fQueueP->GetTail())
        fCurrentElemP = NULL;
    else
        fCurrentElemP = fCurrentElemP->Prev();
}


OSQueueElem* OSQueue_Blocking::DeQueueBlocking(OSThread* inCurThread, SInt32 inTimeoutInMilSecs)
{
    OSMutexLocker theLocker(&fMutex);
#ifdef __Win32_
     if (fQueue.GetLength() == 0) 
	 {	fCond.Wait(&fMutex, inTimeoutInMilSecs);
		return NULL;
	 }
#else
    if (fQueue.GetLength() == 0) 
        fCond.Wait(&fMutex, inTimeoutInMilSecs);
#endif

    OSQueueElem* retval = fQueue.DeQueue();
    return retval;
}

OSQueueElem*    OSQueue_Blocking::DeQueue()
{
    OSMutexLocker theLocker(&fMutex);
    OSQueueElem* retval = fQueue.DeQueue(); 
    return retval;
}


void OSQueue_Blocking::EnQueue(OSQueueElem* obj)
{
    {
        OSMutexLocker theLocker(&fMutex);
        fQueue.EnQueue(obj);
    }
    fCond.Signal();
}



sunxiaopengsun
关注
专栏目录
嵌入式系统使用Cmake控制编译
weixin_34199405的博客
12-20 1253
2019独角兽企业重金招聘Python工程师标准>>> ...
RAW-OS学习之——消息队列（queue）
fanwenjieok的专栏
07-10 1581
RAW-OS学习之——消息队列（queue）
router os中的queues问题
weixin_33743248的博客
11-04 164
router os中的queues有几种 1 simple队列中tigger目标地址是针对所指定的地址进行UP,DOWN的限速，并非source的意义。 2 PCQ队列和simple技术结合使用的时候，可以针对内网地址进行每IP限速 具体做法是 1. Mark all packets with packet-mark all:/ip firewall mangle a...
linux内核的 等待队列 使用方法，wait_queue_head_t，进程休眠
听说读写
09-07 879
<br />当你在用户空间需要读写一大片数据的时候，这个就用上了。<br />以下来自：http://www.yuanma.org/data/2006/1207/article_1916.htm假设我们在 kernel 里产生一个 buffer，user 可以经由 read，write 等 system call 来读取或写资料到这个 buffer 里。如果有一个 user 写资料到 buffer 时，此时 buffer 已经满了。那请问你要如何去处理这种情形呢 ? 第一种，传给 user 一个错误讯息，说
数据结构与算法-(8)---队列(Queue)
“路漫漫其修远兮，吾将上下求索。”
10-15 379
队列的概念及特点+热土豆问题
Router OS全攻略
weixin_34006965的博客
07-12 199
Router OS全攻略崔北亮(CCIE) 本书针对当前网络的突出问题（譬如带宽控制、服务优先、BT下载、QQ聊天、认证计费、网络安全、异地互联和无线接入等），从网络管理工作的实际需要出发，给出各种解决方案。书中全面、系统的介绍了Router OS在网络建设和管理中的各种应用。全书共十七章，内容包括Router OS安装、命令行介绍、NAT配置、路由原理和配置、...
ucos ii 源代码
01-12
例如，`ostask.c`包含了任务管理的实现，`ostime.c`负责时间管理，`osevent.c`处理事件如信号量和互斥锁，而`osqueue.c`实现消息队列。对应的头文件如`ostask.h`、`ostime.h`、`osevent.h`和`osqueue.h`定义了相关的...
uCOS-II-V2.85-Source-Code.rar_V2 _ucos ii2.
09-24
此外，源代码中还包括了示例应用，这些应用展示了如何在实际项目中使用uCOS-II的各个功能。通过分析这些示例，开发者能够快速上手，并在自己的项目中灵活运用。 总结，uCOS-II V2.85源代码提供了一个深入了解嵌入式...
【编程题】使用LiteOS操作系统编程的过程中，已实现了任务入口函数void LED_task（），请用代码创建这个任务UINT32 create_LED_task() ，并配置任务优先级为11
最新发布
10-21
在 LiteOS 操作系统编程中，创建并初始化一个任务通常涉及到以下几个步骤。首先，你需要包含必要的头文件，并定义任务的相关信息，如名称、... os_eventq_service(os_get_system_osqueue()); // 处理系统事件队列 } }
Apple公司Darwin流式服务器源代码分析
05-23
例如，通过定义统一的接口，如OSMutex、OSQueue等，来实现跨平台的功能。 #### 五、总结 Apple公司的Darwin流式服务器(DSS)是一款优秀的开源流媒体服务器软件，它不仅具有强大的实时流媒体传输能力，而且还支持...
Router OS 入门记 5--队列树限速
weixin_34202952的博客
03-12 185
今晚弄队列树限速 没成功。出现了 限速失败 FTP传输居然还有6M/S的速度 明明限定额5M带宽 到底什么问题呢？！ 是不是需要单IP限速？那先试试单限速 还有今晚收获就是弄了两个FTP····明天继续搞。 转载于:https://blog.51cto.com/apppanda/804121...
iOS 性能优化-启动优化、main函数之前优化-二进制重排
hengsf123456的博客
05-24 548
一个app的启动时间，很大程度会影响用户的体验，之前我们已经探究过dyld加载的流程，启动流程分为main函数之前和main函数之后。 时间检测 我们可以设置环境变量DYLD_PRINT_STATISTICS来检测，这样可以查看main函数前的打印时间。 dylib loading time:加载动态库 rebase/binding time: ASLR随机生成一个地址，重新绑定地址/映射 ObjC setup time:OC类的注册 initializer time:load方法的加载
OSHeap 和OSQueue的使用例子
lgs7907
01-19 304
李国帅 2018/1/19Darwin流媒体容器的使用例子#include "Win32header.h" #include "OSMemory.h" #include "OS.h" #include "OSQueue.h" #include "OSHeap.h" int main(int argc, char* argv[]) { int* inObjectP = new int()
基于嵌入式OS层的初步了解
AN15778423590的博客
09-26 1380
序言 在实际开发中，如果程序等待一个事件发生，传统的无RTOS情况下，要么在原地一直等待而不能执行其它任务，要么使用状态机机制处理。而RTOS提供事件驱动型设计方式，只是在处理实际任务时才会运行，这能够更合理的利用CPU，也可以很方便的将当前任务阻塞在该事件下，然后自动去执行别的任务，这显然更方便，并且可以高效的利用CPU。处理这类事件，是我使用RTOS的最大动力。 （1）大多数RTOS代码都具有一定规模，任何代码都可能带来BUG，何况是代码具有一定规模的RTOS，因此引入RTOS的同时也可能会引入该RTO
μC/OS-II的初始化和启动过程
Nickee-Lin的博客
11-11 1092
初始化和启动都在main函数里实现。 1、初始化 为了完成自身的工作，μC/OS-II定义了大量的全局数据结构，要让系统跑起来，需要先初始化各种需要的全局变量。 1. OS首先Initialize了任务控制块、事件控制表，还有一些条件编译的初始化（也就是说这些可以不要，改变一下宏定义就好了，这就是μC/OS-II的剪裁性，具体**宏定义全都在os_cfg.h**文件里。） 2. 初始化之后，创建了一个空闲任务，这个
W801/W800-wifi-socket开发(二)-UDP蓝牙控制wifi连接
qq_37280428的博客
04-19 9574
这是目录一、项目概述二、项目设计三、程序设计四、测试4.1、连接测试4.2 重连测试4.3 停止测试 本文使用环境： 主控：W800-KIT (开发板) 兼容：W800 W801 AIR101 开发环境：CDK SDK：W801/W800的SDK(tls库) 我的联盛德问答社区主页 前文： W801/W800-wifi-socket开发(一)-UDP W801蓝牙收发数据与控制设计(一)-INDICATE W801蓝牙收发数据与控制设计(二)-NOTIFY方式 本文github工程 这份代码包含前文的某些函
逐字逐句解析ucos ii 源代码-》OS_CORE.c
一条狗的自我修养
01-31 1548
//BY 简单的元清//部分内容引用了其他博主的文章，对这些博主表示感谢，时间关系就不一一指出了。//如有转载，请说明，谢谢 /* ********************************************************************************************************* *
uc/os-ii事件控制块
fillthesky的博客
07-02 804
任务间的同步依赖于任务间的通信。在μC/OS-II中，使用信号量、互斥信号量、消息邮箱、消息队列、事件标志组这些被称作事件的中间环节来实现任务之间的通信的。为了把描述事件的数据结构统一起来，μC/OS-II使用叫做事件控制块ECB的数据结构来描述诸如信号量、互斥信号量、消息邮箱、消息队列、事件标志组这些事件。
使一个任务进入就绪态，OSEventTaskRdy()
FunkyFrog821951259的博客
03-23 2170
程序清单 L6.6是函数OSEventTaskRdy()的源代码。当发生了某个事件，该事件等待任务列表中的最高优先级任务（Highest Priority Task – HPT）要置于就绪态时，该事件对应的OSSemPost()，OSMboxPost()，OSQPost()，和OSQPostFront()函数调用OSEventTaskRdy()实现该操作。换句话说，该函数从等待任务队列中删除HPT
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

sunxiaopengsun

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

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

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

打赏作者

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

抵扣说明：

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

余额充值