ucos-II全局变量、事件、信号量集标志组分别实现哲学家就餐问题

最新推荐文章于 2024-05-08 15:24:52 发布
最新推荐文章于 2024-05-08 15:24:52 发布
阅读量2.2k 收藏 31
点赞数 12
分类专栏： 嵌入式操作系统 文章标签： 操作系统 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40400656/article/details/105258411
版权
哲学家就餐问题

    有5个哲学家，其生活方式是交替的进行思考和进餐。他们共用一张圆桌，分别坐在周围的5张椅子上，在圆桌上有五个碗和五支筷子，平时哲学家进行思考，饥饿时便试图取其左、右靠近他的筷子，只有在他拿到两支筷子时才能进餐。进餐毕，放下筷子继续思考，要求如下：

  • 键盘上的按键0到1分别代表5个哲学家申请吃饭。
  • 要求列出所有可能出现的状况，而且屏幕上必须将最新的状态显示出来。注：申请进餐未果维持5s后改为显示正在思考。
  • 每位哲学家的进餐时间为20s（需要显示倒计时），进餐次数不做限定。
  • 分别用全局变量（不用事件和信号量集标志组）、事件、信号量集标志组实现。

全局变量实现：

#include "INCLUDES.H"
#define TASK_SIZE_STK 512
#define TIME 40
OS_STK StartTaskStk[TASK_SIZE_STK];
OS_STK PhiTaskStk[5][TASK_SIZE_STK];
OS_STK KeyTaskStk[TASK_SIZE_STK];
INT8U x = 0, y = 0;
INT16S Key;
BOOLEAN KeyFlag;
INT8U PhiID[] = {1, 2, 3, 4, 5};   //哲学家编号
INT8U Stick[] = {1, 1, 1, 1, 1};   //全局变量,1代表筷子未被占用
INT16S KeyArray[] = {0x1B, 0x31, 0x32, 0x33, 0x34, 0x35};
//对应Esc,1,2,3,4,5按键
INT8U i;

void StartTask(void *pdata);
void PhiTask(void *pdata);
void KeyTask(void *pdata);
void Eat(INT8U x);
void Think(INT8U x);
void Fail(INT8U x);
void Reply(INT8U x);

void main()
{
    OSInit();
    PC_DOSSaveReturn();
    PC_VectSet(uCOS, OSCtxSw);
    OSTaskCreate(StartTask, (void *)0,
                 &StartTaskStk[TASK_SIZE_STK - 1], 0);
    OSTaskCreate(KeyTask, (void *)0,
                 &KeyTaskStk[TASK_SIZE_STK - 1], 1);
    OSStart();
}

void StartTask(void *pdata)
{
    INT8U err;
    char temp[50];
#if OS_CRITICAL_METHOD == 3
    OS_CPU_SR cpu_sr
#endif
    pdata = pdata;
    OS_ENTER_CRITICAL();
    PC_VectSet(0x08, OSTickISR);
    PC_SetTickRate(OS_TICKS_PER_SEC);
    OS_EXIT_CRITICAL();
    OSStatInit();
    for(i = 0; i < 5; i++)
    {
        err = OSTaskCreate(PhiTask, (void *)&PhiID[i],
                           &PhiTaskStk[i][TASK_SIZE_STK - 1], i + 2);
        if(err == OS_NO_ERR)
        {
            sprintf(temp, "Task %d create successfully", i);
            PC_DispStr(2, 20 + i, temp,
                       DISP_BGND_BLACK + DISP_FGND_WHITE);
        }
    }
    //创建完成后挂起自己
    OSTaskSuspend(OS_PRIO_SELF);
}

void KeyTask(void *pdata)
{
    pdata = pdata;
    for(;;)
    {
        KeyFlag = PC_GetKey(&Key);
        if(Key == KeyArray[0])
        {
            PC_DOSReturn();
        }
        OSTimeDly(1);
    }
}

void PhiTask(void *pdata)
{
    //这里只能用局部变量，即为5个任务单独分配空间
    INT8U ID;
    char temp[50];
    INT8U j;
    INT32U time = 0;
    pdata = pdata;
    ID = *(INT8U *)pdata;

    for(;;)
    {
        //读取到相应的按键
        if(Key == KeyArray[ID])
        {
            for(j = 0; j < 5; j++)
            {
                if(Stick[ID - 1] == 1 && Stick[ID % 5] == 1)
                {
                    Stick[ID - 1] = 0;
                    Stick[ID % 5] = 0;
                    j = 6;
                    Eat(ID);
                }
                else if(j < 4)
                {
                    //显示申请
                    Reply(ID);
                }
                else if(j == 4)
                {
                    //已经5s还不满足条件
                    Fail(ID);
                }
                else
                {
                    Think(ID);
                }
                OSTimeDlyHMSM(0, 0, 1, 0);
            }
            OSTimeDly(1);
        }
        else
        {
            Think(ID);
            OSTimeDly(1);
        }
    }
}

void Eat(INT8U ID)
{
    INT8U j;
    char temp[50];
    sprintf(temp, "Philos %d is eating                   ", ID);
    PC_DispStr(x, ID, temp,
               DISP_BGND_BLACK + DISP_FGND_WHITE);

    for(j = TIME; j < 60; j++)
    {
        if(j < 60)
        {
            //倒计时从60 - TIME开始
            sprintf(temp, "countdown: %d s ", 60 - j);
            PC_DispStr(24, ID, temp, DISP_BGND_BLACK + DISP_FGND_GREEN);
            OSTimeDlyHMSM(0, 0, 1, 0);
        }
        if(j == 59)
        {
            Stick[ID - 1] = 1;
            Stick[ID % 5] = 1;
            OSTimeDly(1);
        }
    }
}

void Think(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d is thinking                   ", ID);
    PC_DispStr(x, ID, temp,
               DISP_BGND_BLACK + DISP_FGND_WHITE);
}

void Fail(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d apply for meal failed ", ID);
    PC_DispStr(x, ID, temp, DISP_BGND_BLACK + DISP_FGND_RED);
}

void Reply(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d is replying for meal  ", ID);
    PC_DispStr(x, ID, temp, DISP_BGND_BLACK + DISP_FGND_RED);
    //申请的过程中如果也满足了条件,则同样跳转至Eat函数
    if(Stick[ID - 1] == 1 && Stick[ID % 5] == 1)
    {
        Stick[ID - 1] = 0;
        Stick[ID % 5] = 0;
        Eat(ID);
    }
}

事件实现：

#include "INCLUDES.H"
#define TASK_SIZE_STK 512
#define TIME 50
OS_STK StartTaskStk[TASK_SIZE_STK];
OS_STK PhiTaskStk[5][TASK_SIZE_STK];
OS_STK KeyTaskStk[TASK_SIZE_STK];
INT8U PhiID[] = {1, 2, 3, 4, 5};
INT8U x = 0, y = 0;
INT8U i;
INT16S Key;
BOOLEAN KeyFlag;
INT16S KeyArray[] = {0x1B, 0x31, 0x32, 0x33, 0x34, 0x35};
OS_EVENT *Semp[5];  //声明5个信号量

void StartTask(void *pdata);
void PhiTask(void *pdata);
void KeyTask(void *pdata);
void Eat(INT8U ID);
void Think(INT8U ID);
void Fail(INT8U ID);
void Reply(INT8U ID);

void main()
{
    OSInit();
    PC_DOSSaveReturn();
    PC_VectSet(uCOS, OSCtxSw);
    OSTaskCreate(StartTask, (void *)0,
                 &StartTaskStk[TASK_SIZE_STK - 1], 0);
    OSTaskCreate(KeyTask, (void *)0,
                 &KeyTaskStk[TASK_SIZE_STK - 1], 1);
    OSStart();
}

void StartTask(void *pdata)
{
    INT8U err;
    char temp[50];
#if OS_CRITICAL_METHOD == 3
    OS_CPU_SR cpu_sr
#endif
    pdata = pdata;
    OS_ENTER_CRITICAL();
    PC_VectSet(0x08, OSTickISR);
    PC_SetTickRate(OS_TICKS_PER_SEC);
    OS_EXIT_CRITICAL();
    OSStatInit();
    for(i = 0; i < 5; i++)
    {
        err = OSTaskCreate(PhiTask, (void *)&PhiID[i],
                           &PhiTaskStk[i][TASK_SIZE_STK - 1], i + 2);
        if(err == OS_NO_ERR)
        {
            sprintf(temp, "Task %d Creats Successfully", i);
            PC_DispStr(2, 20 + i, temp,
                       DISP_FGND_WHITE + DISP_BGND_BLACK);
        }
        //定义5个信号量,初值为1
        Semp[i] = OSSemCreate(1);
        if(Semp[i] != (OS_EVENT *)0)
        {
            sprintf(temp, "Semphore %d Creates Successfully", i);
            PC_DispStr(40, 20 + i, temp,
                       DISP_BGND_BLACK + DISP_FGND_WHITE);
        }
    }
    OSTaskSuspend(OS_PRIO_SELF);

}

void KeyTask(void *pdata)
{
    pdata = pdata;
    for(;;)
    {
        KeyFlag = PC_GetKey(&Key);
        if(Key == KeyArray[0])
        {
            PC_DOSReturn();
        }
        OSTimeDly(1);
    }
}

void PhiTask(void *pdata)
{
    char temp[50];
    INT8U err1, err2;
    INT32U  time;
    INT8U ID;
    pdata = pdata;
    ID = *(INT8U *)pdata;
    for(;;)
    {
        if(Key == KeyArray[ID])
        {
 
            sprintf(temp, "Philos %d is applying for meal ", ID);
            PC_DispStr(x, ID, temp, DISP_BGND_BLACK + DISP_FGND_RED);
          
            time = OSTimeGet();
            OSSemPend(Semp[ID - 1], 1000, &err1);
            time = OSTimeGet() - time;
            OSSemPend(Semp[ID % 5], 1001 - time, &err2);
            if(err1 == OS_NO_ERR && err2 == OS_NO_ERR)
            {
                //都申请成功,直接跳转到Eat函数
                Eat(ID);
            }
            else if(err1 == OS_NO_ERR && err2 == OS_TIMEOUT)
            {
                OSSemPost(Semp[ID - 1]);
                Fail(ID);
            }
            else if(err1 == OS_TIMEOUT && err2 == OS_NO_ERR)
            {
                OSSemPost(Semp[ID % 5]);
                Fail(ID);
            }
            else
            {
                Think(ID);
            }
            OSTimeDly(1);
        }
        else
        {
            Think(ID);
            OSTimeDly(1);
        }
    }
}

void Eat(INT8U ID)
{
    char temp[50];
    INT8U j;
    sprintf(temp, "Philos %d is eating               ", ID);
    PC_DispStr(x, ID, temp,
               DISP_FGND_WHITE + DISP_BGND_BLACK);
    for(j = TIME; j < 60; j++)
    {
        if(j <= 59)
        {
            sprintf(temp, "last time: %d      ", 60 - j);
            PC_DispStr(24, ID, temp,
                       DISP_FGND_WHITE + DISP_BGND_BLACK);
            OSTimeDlyHMSM(0, 0, 1, 0);
        }
        if(j == 59)
        {
            OSSemPost(Semp[ID - 1]);
            OSSemPost(Semp[ID % 5]);
            OSTimeDly(1);
        }
    }
}

void Think(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d is thinking                     ", ID);
    PC_DispStr(x, ID, temp,
               DISP_BGND_BLACK + DISP_FGND_WHITE);
}

void Fail(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d reply for meal failed           ", ID);
    for(i = 0; i < 2; i++)
    {
        PC_DispStr(x, ID, temp,
                   DISP_BGND_BLACK + DISP_FGND_WHITE);
        OSTimeDlyHMSM(0, 0, 0, 400);
    }
}

void Reply(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d is thinking                     ", ID);
    PC_DispStr(x, ID, temp,
               DISP_BGND_BLACK + DISP_FGND_WHITE);
}

信号量集标志组实现:

#include "INCLUDES.H"
#define TASK_SIZE_STK 512
#define TIME 50
OS_STK StartTaskStk[TASK_SIZE_STK];
OS_STK PhiTaskStk[5][TASK_SIZE_STK];
OS_STK KeyTaskStk[TASK_SIZE_STK];
INT8U PhiID[] = {1, 2, 3, 4, 5};
INT8U x = 0, y = 0;
INT8U i;
INT16S Key;
BOOLEAN KeyFlag;
INT16S KeyArray[] = {0x1B, 0x31, 0x32, 0x33, 0x34, 0x35};
//声明信号量集,只需要1个即可
OS_FLAG_GRP *Semp_F;

INT8U Flag_Location[] = {0, 3, 6, 12, 24, 17};

void StartTask(void *pdata);
void PhiTask(void *pdata);
void KeyTask(void *pdata);
void Eat(INT8U ID);
void Think(INT8U ID);
void Fail(INT8U ID);
void Reply(INT8U ID);

void main()
{
    OSInit();
    PC_DOSSaveReturn();
    PC_VectSet(uCOS, OSCtxSw);
    OSTaskCreate(StartTask, (void *)0,
                 &StartTaskStk[TASK_SIZE_STK - 1], 0);
    OSTaskCreate(KeyTask, (void *)0,
                 &KeyTaskStk[TASK_SIZE_STK - 1], 1);
    OSStart();
}

void StartTask(void *pdata)
{
    INT8U err;
    char temp[50];
#if OS_CRITICAL_METHOD == 3
    OS_CPU_SR cpu_sr
#endif
    pdata = pdata;
    OS_ENTER_CRITICAL();
    PC_VectSet(0x08, OSTickISR);
    PC_SetTickRate(OS_TICKS_PER_SEC);
    OS_EXIT_CRITICAL();
    OSStatInit();
    for(i = 0; i < 5; i++)
    {
        err = OSTaskCreate(PhiTask, (void *)&PhiID[i],
                           &PhiTaskStk[i][TASK_SIZE_STK - 1], i + 2);
        if(err == OS_NO_ERR)
        {
            sprintf(temp, "Task %d Creats Successfully", i);
            PC_DispStr(2, 20 + i, temp,
                       DISP_FGND_WHITE + DISP_BGND_BLACK);
        }
    }
    Semp_F = OSFlagCreate(255, &err);
    if(err == OS_NO_ERR)
    {
        sprintf(temp, "OS_FLAG Creats Successfully");
        PC_DispStr(40, 20, temp,
                   DISP_FGND_WHITE + DISP_BGND_BLACK);
    }
    OSTaskSuspend(OS_PRIO_SELF);

}

void KeyTask(void *pdata)
{
    pdata = pdata;
    for(;;)
    {
        KeyFlag = PC_GetKey(&Key);
        if(Key == KeyArray[0])
        {
            PC_DOSReturn();
        }
        OSTimeDly(1);
    }
}

void PhiTask(void *pdata)
{
    char temp[50];
    INT8U errPhi;
    INT8U ID;
    pdata = pdata;
    ID = *(INT8U *)pdata;
    for(;;)
    {
        if(Key == KeyArray[ID])
        {
            sprintf(temp, "Philos %d is applying for meal ", ID);
            PC_DispStr(x, ID, temp, DISP_BGND_BLACK + DISP_FGND_RED);
            OSFlagPend(Semp_F,
                       (OS_FLAGS)Flag_Location[ID],
                       OS_FLAG_WAIT_SET_ALL + OS_FLAG_CONSUME,
                       1000, &errPhi
                      );
            if(errPhi == OS_NO_ERR)
            {
                Eat(ID);
            }
            else
            {
                Fail(ID);
            }
        }
        else
        {
            Think(ID);
            OSTimeDly(1);
        }
    }
}

void Eat(INT8U ID)
{
    char temp[50];
    INT8U j;
    INT8U err;
    sprintf(temp, "Philos %d is eating                    ", ID);
    PC_DispStr(x, ID, temp,
               DISP_FGND_WHITE + DISP_BGND_BLACK);
    for(j = TIME; j < 60; j++)
    {
        if(j <= 59)
        {
            sprintf(temp, "last time: %d      ", 60 - j);
            PC_DispStr(24, ID, temp,
                       DISP_FGND_WHITE + DISP_BGND_BLACK);
            OSTimeDlyHMSM(0, 0, 1, 0);
        }
        if(j == 59)
        {
            OSFlagPost(Semp_F, (OS_FLAGS)Flag_Location[ID], OS_FLAG_SET, &err);
            OSTimeDly(1);
        }
    }
}

void Think(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d is thinking                     ", ID);
    PC_DispStr(x, ID, temp,
               DISP_BGND_BLACK + DISP_FGND_WHITE);
}

void Fail(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d reply for meal failed           ", ID);
    for(i = 0; i < 2; i++)
    {
        PC_DispStr(x, ID, temp,
                   DISP_BGND_BLACK + DISP_FGND_WHITE);
        OSTimeDlyHMSM(0, 0, 0, 400);
    }
}

void Reply(INT8U ID)
{
    char temp[50];
    sprintf(temp, "Philos %d is thinking                     ", ID);
    PC_DispStr(x, ID, temp,
               DISP_BGND_BLACK + DISP_FGND_WHITE);
}
梦远花落白衣衫
关注
  • 12
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ucos-ii学习笔记——信号量集(事件标志组)的原理及使用
04-22
详细介绍了ucos-ii操作系统的信号量集(事件标志组)的原理及使用，程序完美可以运行，注释详细，希望对你能有所帮助
µCOS-II 信号量试验——哲学家就餐问题
01-24
嵌入式µCOS-II操作下的信号量实验——哲学家就餐问题实验报告
μC/OS-II实验：实验三 信号量： 哲学家就餐问题
fovwin的专栏
08-18 6166
实验描述： 五个哲学家任务（ph1、ph2、ph3、ph4、ph5）主要有两种过程：思考（即睡眠一段时间）和就餐。每个哲学家任务在就餐前必须申请并获得一左一右两支筷子，就餐完毕后释放这两支筷子。五个哲学家围成一圈，每两人之间有一支筷子。一共有五支筷子，在该实验中用了五个互斥信号量来代表。如下图所示： 涉及的μC/OS-II系统函数： 实验代码：  app
µC/OS-II 综合实验 ucos 哲学家就餐问题的实现
Glasier的博客
01-27 1902
五个哲学家任务（ph1、ph2、ph3、ph4、ph5）主要有两种过程：思考（即睡眠一段时间）和就餐。每个哲学家任务在就餐前必须申请并获得一左一右两支筷子，就餐完毕后释放这两支筷子。五个哲学家围成一圈，每两人之间有一支筷子。一共有五支筷子，在该实验中用了五个互斥信号量来代表。 程序： #include "includes.h" #define TASK_STK_SIZE 512 ...
操作系统~信号量机制如何实现同步、解决吸烟者问题、解决哲学家进餐问题
Shangxingya的博客
02-13 1658
文章目录信号量机制整型信号量记录型信号量总结信号量机制实现进程互斥信号量机制实现进程同步解决吸烟者问题解决哲学家进餐问题 信号量机制 用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。 信号量其实就是一个变量（可以是一个整数，也可以是更复杂的记录型变量)，可以用一个信号量来表示系统中某种资源的数量，比如:系统中只有一台打印机，就可以设置一个初值为1的信号量。 原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。 原语是由关中断/开中断指令实现的。 软件解
哲学家就餐问题（uc/OS II）
qq_16231155的博客
04-30 3007
哲学家就餐问题    五个哲学家，共用一张圆桌，分别坐在周围的5张椅子上，在圆桌上有5个碗和五支筷子，平时哲学家进行思考，饥饿时便试图取其左、右靠近他的筷子，只有在他拿到两只筷子时才能进餐。进餐完后，放下筷子思考。要求：    1、键盘上的按键1-5分别代表5个哲学家申请吃饭    2、要求列出所有可能出现的状况，而且屏幕上必须将最新状态显示出来   （1）哲学家i正在进餐，哲学家i对应的状态显示...
基于ucos-ii的哲学家就餐问题
12-07
基于ucos的哲学家就餐问题源代码，程序，已经运行，点击运行程序即可运行。
操作系统：哲学家就餐问题的奇偶解决方法（含代码）
俊夫小瞳的博客
06-20 5076
1. 原理说明0、1、2、3、4为哲学家 ⓪、①、②、③、④为筷子哲学家就餐问题是一种一个进程需要两个临界资源的问题。 如果每位哲学家都先拿自己左边的筷子，那么此时没有冲突，每位哲学家都可以拿到自己左边的筷子。 但是接下来每位哲学家都去拿自己右边的筷子时，右边的筷子已经被右边的哲学家拿走了，那么所有的哲学家就只能等着自己右边的哲学家把其左边的筷子放下才能继续就餐，因此整个程序会陷入永久阻塞。这种每个进程都在等待其他进程释放资源或者是等待其他进程给出所需数据而无限期陷入僵持的状态，称为死锁。为了解决哲学家就餐
ucos中如何定义全局变量
subkiller的专栏
03-21 5811
<br />    以下是如何定义全局变量。众所周知，全局变量应该是得到内存分配且可以被其他模块通过C语言中extern关键字调用的变量。因此，必须在 .C 和 .H 文件中定义。这种重复的定义很容易导致错误。以下讨论的方法只需用在头文件中定义一次。虽然有点不易懂,但用户一旦掌握，使用起来却很灵活。表1.2中的定义出现在定义所有全局变量的.H头文件中。<br /> <br />程序清单   定义全局宏。<br />#ifdef   xxx_GLOBALS<br />#define  xxx_EXT<br /
DJ2-5 哲学家进餐问题
狂放不羁霸的博客
03-24 563
1. 问题描述 2. 问题分析 3. 利用记录型信号量解决哲学家就餐问题 4. 利用 AND 信号量解决哲学家就餐问题
基于 ucos-ii操作系统解决哲学家就餐问题
11-24
在ucos2操作系统下，解决互锁问题。即公共资源的分配问题。
uCOS-II信号量集.ppt
03-27
在嵌入式实时内核中，信号量是指一种表明预先定义的...信号量集可以用一个指定长度的变量（比如一个32位的无符号整型变量，不同的操作系统其具体实现不一样）来表示，而每个信号量由在信号量集变量中的某一位来代表。
uCOS-II.rar_uCOS II_信号量_嵌入式
09-23
嵌入式操作系统 ucosII的详细介绍，系统结构，线程管理，信号量控制
哲学家就餐问题及解决方法
知识不加糖的分享圈
04-14 7674
问题描述 哲学家就餐问题(Dining philosophers problem)是在计算机科学中的一个经典问题，用来演示在并发计算中多线程同步时产生的问题。 在1971年，著名的计算机科学家艾兹格·迪科斯彻提出了一个同步问题，即假设有五台计算机都试图访问五份共享的磁带驱动器。稍后，这个问题被托尼·霍尔重新表述为哲学家就餐问题。这个问题可以用来解释死锁和资源耗尽。 哲学家就餐问题可以这样表述，假设...
经典进程同步问题（二）——哲学家进餐问题
aimat2020的博客
12-02 5335
哲学家就餐问题详解（附完整代码）：三种方案解决死锁问题
多线程小题 ——哲学家就餐问题
小玉的博客
10-10 773
一、分析问题 哲学家从不交谈 分析： 1、筷子相当于临界资源（在一段时间内只允许一个进程访问的资源，如打印机） 2、产生死锁的原因主要有2点: 1是竞争资源 ; 2是进程推进顺序不当 3、资源加锁，用来保证在某个时刻，资源只能被一个程序或一段代码访问 4、用附加规则解决哲学家进餐问题： 为了预防死锁的产生，我们添加一条竞争规则：所有哲学家先竞争奇数号筷子，获得后才能去竞争偶数号筷子（由于5号哲学...
详解经典进程同步问题（生产者消费者问题/哲学家进餐问题/读者写者问题）_OS
weixin_45951642的博客
05-07 4994
1. 利用信号量实现进程的同步和互斥 利用信号量实现进程互斥 为使多个进程能互斥地访问某临界资源，只须为该资 源设置一个互斥信号量 mutex，并设其初始值为 1，然后将各进程访问该资源的临界区 CS 置于 wait(mutex) 和 signal(mutex) 操作之间即可。 在进程互斥中使用 P、V 操作，须在同一程序段成对出 现同一信号量的 P、V 操作，否则会造成系统瘫痪。 注意： 实现互斥的信号量的PV操作必须在同一程序当中成对的出现...
java jar包如何运行或调用
最新发布
NLP与推荐算法
05-08 236
java服务启动
简要说明uCOS-II操作系统的文件组成
06-11
uCOS-II操作系统的文件组成包括以下几个文件： 1. OS_CORE.C：uCOS-II操作系统的核心文件，包括任务管理、时间管理、事件管理等核心功能的实现。 2. OS_CPU_C.C：uCOS-II操作系统的CPU相关文件，包括任务切换、中断处理等与CPU相关的操作的实现。 3. OS_TICK.C：uCOS-II操作系统的时钟节拍文件，用于实现操作系统中的时间管理功能。 4. OS_MEM.C：uCOS-II操作系统的内存管理文件，用于实现动态内存分配和释放功能。 5. OS_Q.C：uCOS-II操作系统的消息队列文件，用于实现任务间的消息传递功能。 6. OS_SEM.C：uCOS-II操作系统的信号量文件，用于实现任务间的同步和互斥操作。 7. OS_TASK.C：uCOS-II操作系统的任务文件，包括任务的创建、删除、挂起、恢复等任务管理操作的实现。 8. OS_FLAG.C：uCOS-II操作系统的事件标志文件，用于实现任务间的事件通知和等待功能。 9. OS_MUTEX.C：uCOS-II操作系统的互斥信号量文件，用于实现任务间的互斥操作。 以上这些文件构成了uCOS-II操作系统的核心组成部分，通过它们的协同工作，实现了一个完整的实时操作系统。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值