若干简单的进程和作业调度的C++模拟程序

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› C++›C++教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

进程调度（时间片轮转，动态优先级，链表形式）：

#include<cstdio>
#include<cstdlib>

struct PCB
{
    char name[10];
    char state; //状态
    int super; //优先级
    int ntime; //预计运行时间
    int rtime; //实际运行时间
    PCB *link;
}*ready=NULL, *p;

void disp(PCB *pr) /*建立进程显示函数,用于显示当前进程 */
{
    printf("\n qname \t state \t super \t ntime \t rtime \n");
    printf("|%s \t ",pr->name);
    printf("|%c \t ",pr->state);
    printf("|%d \t ",pr->super);
    printf("|%d \t ",pr->ntime);
    printf("|%d \t ",pr->rtime);
    printf("\n");
}

void check() /* 建立进程查看函数 */
{
    printf("\n ******** 当前正在运行的进程是:%s",p->name); /* 显示当前运行进程 */
    disp(p);

    printf("\n ******** 当前就绪队列状态为:\n"); /* 显示就绪队列状态 */
    PCB *pr=ready;
    while(pr!=NULL) disp(pr), pr=pr->link;
}

void sort() /* 建立对进程进行优先级排列函数 */
{
    if(ready==NULL || (p->super)>(ready->super)) /* 优先级最大者,插入队首 */
    {
        p->link=ready;
        ready=p;
    }
    else /* 进程比较优先级,插入适当的位置中 */
    {
        PCB *first=ready, *second=first->link;
        while(second!=NULL)
        {
            if((p->super)>(second->super)) /* 若插入进程比当前进程优先数大,插入到当前进程前面 */
            {
                first->link=p;
                p->link=second;
                return;
            }

            first=first->link;
            second=second->link;
        }
        first->link=p;
    }
}

void input() /* 建立进程控制块函数 */
{
    system("cls");

    printf("\n 请输入进程数目?");
    int num; scanf("%d",&num);

    for(int i=0;i<num;i++)
    {
        printf("\n 进程号 No.%d:\n",i);
        p=(PCB *)malloc(sizeof(PCB));

        printf("\n 输入进程名:");
        scanf("%s",p->name);

        printf("\n 输入进程优先数:");
        scanf("%d",&(p->super));

        printf("\n 输入进程运行时间:");
        scanf("%d",&(p->ntime));

        printf("\n");

        p->rtime=0;
        p->state='w';
        p->link=NULL;

        sort(); /* 调用 sort 函数 */
    }

    system("cls");
    printf("\n ******** 进程创建如下:\n");
    PCB *pr=ready;
    while(pr!=NULL) disp(pr), pr=pr->link;
}

inline void destroy() /*建立进程撤消函数(进程运行结束,撤消进程) */
{
    printf("\n 进程 [%s] 已完成.\n",p->name), free(p);
}

inline void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态) */
{
    (p->rtime)++;
    if(p->rtime==p->ntime)
        destroy(); /* 调用 destroy 函数 */
    else
        --(p->super), p->state='w', sort();
}

int main() /*主函数*/
{
    input();

    int h=0;
    while(ready!=NULL)
    {
        getchar();
        printf("\n The execute number:%d \n",++h);

        p=ready;
        ready=p->link;
        p->link=NULL;
        p->state='r';

        check();
        running();

        printf("\n 按任意键继续......"), getchar();
    }

    printf("\n\n 进程已经全部完成.\n");
    getchar();

    return 0;
}

/*
3
A
3
5
B
2
3
C
1
4
*/

作业调度（FCFS调度）：

#include<bits/stdc++.h>
using namespace std;

int cur_time;
int limit;
double turnover_time_sum, weighted_turnover_time_sum;

struct JCB
{
    int index; //作业序号
    string name; //作业名称
    string state; //状态
    int estimate_time; //预计运行时间
    int arrive_time; //到达时间
    int running_time; //实际运行时间
    int end_time; //结束时间
    inline int turnover_time()const //周转时间
    {
        return cur_time-arrive_time;
    }
    inline double weighted_turnover_time()const
    {
        return turnover_time()*1.0/running_time;
    }
    inline int waiting_time()const //等待时间
    {
        return turnover_time()-running_time;
    }

    void print()const
    {
        printf("作业 %d : \t",index);
        cout<<"|名称: "<<name<<" \t";
        cout<<"|状态: "<<state<<" \t";
        printf("|到达: %d \t",arrive_time);
        printf("|预计运行: %d \t",estimate_time);
        printf("|已运行: %d \t",running_time);
        printf("|已等待: %d \t",waiting_time());
        if(state=="destroy")
        {
            printf("|周转时间: %d \t",turnover_time());
            printf("|带权周转: %.2f",weighted_turnover_time());
        }
        printf("\n");
    }
};
bool cmp(const JCB &a,const JCB &b)
{
    return a.arrive_time<b.arrive_time;
}

vector<JCB> memory; //内存
queue<JCB> fifo; //FIFO队列
vector<JCB> destroy; //待销毁

JCB createJob(int index) //创建
{
    JCB res;

    printf("\n\n作业序号: %d\n",res.index=index);
    res.state="reserve";

    printf("请输入作业名称:\n");
    cin>>res.name;

    printf("请输入预计运行时间:\n");
    cin>>res.estimate_time;

    printf("请输入到达时间:\n");
    cin>>res.arrive_time;

    res.running_time=0;

    return res;
}

void printJobs() //输出各个作业情况
{
    printf("\n************************************************************\n");
    printf("目前时间: %d\n",cur_time);

    printf("\n内存中存在 %d 个作业:\n",memory.size());
    for(auto job:memory) job.print();

    queue<JCB> tmp=fifo;
    printf("\n后备队列中存在 %d 个作业:\n",tmp.size());
    while(tmp.size()) tmp.front().print(), tmp.pop();

    printf("\n待销毁 %d 个作业:\n",destroy.size());
    for(auto job:destroy) job.print();

    cout<<endl<<endl<<endl<<endl;
}

void runJobs() //运行内存中的作业
{
    for(unsigned int i=0;i<memory.size();i++)
    {
        memory[i].running_time++;
        if(memory[i].running_time==memory[i].estimate_time)
        {
            memory[i].state="destroy";
            memory[i].end_time=cur_time;
            destroy.push_back(memory[i]);
            memory.erase(memory.begin()+i);
            i--;
        }
    }
}

void destroyJobs() //销毁待销毁的作业
{
    for(unsigned int i=0;i<destroy.size();i++)
    {
        turnover_time_sum+=destroy[i].turnover_time();
        weighted_turnover_time_sum+=destroy[i].weighted_turnover_time();
    }
    destroy.clear();
}


int main()
{
    printf("请输入内存允许的最多作业数目:\n");
    cin>>limit;

    printf("请输入作业总数目:\n");
    int num; cin>>num;

    vector<JCB> tmp;
    for(int i=0;i<num;i++) tmp.push_back(createJob(i));
    sort(tmp.begin(),tmp.end(),cmp);

    cur_time=0;
    turnover_time_sum=weighted_turnover_time_sum=0.0;
    while(tmp.size()>0 || fifo.size()>0 || memory.size()>0)
    {
        while(memory.size()<limit && fifo.size()>0)
        {
            JCB tmp=fifo.front();
            fifo.pop();
            tmp.state="running";
            memory.push_back(tmp);
        }

        for(unsigned int i=0;i<tmp.size();i++)
        {
            if(tmp[i].arrive_time==cur_time)
            {
                fifo.push(tmp[i]);
                tmp.erase(tmp.begin()+i);
                i--;
            }
        }

        runJobs();

        printJobs();

        destroyJobs();

        cur_time++;
    }

    printf("\n\n该组作业平均周转时间 %.2f, 平均带权周转时间 %.2f.\n",turnover_time_sum/num,weighted_turnover_time_sum/num);
}

/*
2
7
YJC
5
3
HBG
3
1
WYY
10
5
QQQ
2
7
ZVD
8
1
WCY
10
10
YJLGXC
7
5
*/

作业调度（SJF调度）：

#include<bits/stdc++.h>
using namespace std;

int cur_time;
int limit;
double turnover_time_sum, weighted_turnover_time_sum;

struct JCB
{
    int index; //作业序号
    string name; //作业名称
    string state; //状态
    int estimate_time; //预计运行时间
    int arrive_time; //到达时间
    int running_time; //实际运行时间
    int end_time; //结束时间
    inline int turnover_time()const //周转时间
    {
        return cur_time-arrive_time;
    }
    inline double weighted_turnover_time()const
    {
        return turnover_time()*1.0/running_time;
    }
    inline int waiting_time()const //等待时间
    {
        return turnover_time()-running_time;
    }

    void print()const
    {
        printf("作业 %d : \t",index);
        cout<<"|名称: "<<name<<" \t";
        cout<<"|状态: "<<state<<" \t";
        printf("|到达: %d \t",arrive_time);
        printf("|预计运行: %d \t",estimate_time);
        printf("|已运行: %d \t",running_time);
        printf("|已等待: %d \t",waiting_time());
        if(state=="destroy")
        {
            printf("|周转时间: %d \t",turnover_time());
            printf("|带权周转: %.2f",weighted_turnover_time());
        }
        printf("\n");
    }

    bool operator<(const JCB &o)const
    {
        return o.estimate_time<estimate_time;
    }
};
bool cmp(const JCB &a,const JCB &b)
{
    return a.arrive_time<b.arrive_time;
}

vector<JCB> memory; //内存
priority_queue<JCB> heap; //优先队列
vector<JCB> destroy; //待销毁

JCB createJob(int index) //创建
{
    JCB res;

    printf("\n\n作业序号: %d\n",res.index=index);
    res.state="reserve";

    printf("请输入作业名称:\n");
    cin>>res.name;

    printf("请输入预计运行时间:\n");
    cin>>res.estimate_time;

    printf("请输入到达时间:\n");
    cin>>res.arrive_time;

    res.running_time=0;

    return res;
}

void printJobs() //输出各个作业情况
{
    printf("\n************************************************************\n");
    printf("目前时间: %d\n",cur_time);

    printf("\n内存中存在 %d 个作业:\n",memory.size());
    for(auto job:memory) job.print();

    priority_queue<JCB> tmp=heap;
    printf("\n后备队列中存在 %d 个作业:\n",tmp.size());
    while(tmp.size()) tmp.top().print(), tmp.pop();

    printf("\n待销毁 %d 个作业:\n",destroy.size());
    for(auto job:destroy) job.print();

    cout<<endl<<endl<<endl<<endl;
}

void runJobs() //运行内存中的作业
{
    for(unsigned int i=0;i<memory.size();i++)
    {
        memory[i].running_time++;
        if(memory[i].running_time==memory[i].estimate_time)
        {
            memory[i].state="destroy";
            memory[i].end_time=cur_time;
            destroy.push_back(memory[i]);
            memory.erase(memory.begin()+i);
            i--;
        }
    }
}

void destroyJobs() //销毁待销毁的作业
{
    for(unsigned int i=0;i<destroy.size();i++)
    {
        turnover_time_sum+=destroy[i].turnover_time();
        weighted_turnover_time_sum+=destroy[i].weighted_turnover_time();
    }
    destroy.clear();
}


int main()
{
    printf("请输入内存允许的最多作业数目:\n");
    cin>>limit;

    printf("请输入作业总数目:\n");
    int num; cin>>num;

    vector<JCB> tmp;
    for(int i=0;i<num;i++) tmp.push_back(createJob(i));
    sort(tmp.begin(),tmp.end(),cmp);

    cur_time=0;
    turnover_time_sum=weighted_turnover_time_sum=0.0;
    while(tmp.size()>0 || heap.size()>0 || memory.size()>0)
    {
        //将若干作业调度运行
        while(memory.size()<limit && heap.size()>0)
        {
            JCB tmp=heap.top(); heap.pop();
            tmp.state="running";
            memory.push_back(tmp);
        }

        //当前时间点到达的作业进入后备队列
        for(unsigned int i=0;i<tmp.size();i++)
        {
            if(tmp[i].arrive_time==cur_time)
            {
                heap.push(tmp[i]);
                tmp.erase(tmp.begin()+i);
                i--;
            }
        }

        runJobs();

        printJobs();

        destroyJobs();

        cur_time++;
    }

    printf("\n\n该组作业平均周转时间 %.2f, 平均带权周转时间 %.2f.\n",turnover_time_sum/num,weighted_turnover_time_sum/num);
}

/*
2
7
YJC
5
3
HBG
3
1
WYY
10
5
QQQ
2
7
ZVD
8
1
WCY
10
10
YJLGXC
7
5
*/

作业调度（HRRN调度）：

#include<bits/stdc++.h>
using namespace std;

int cur_time;
int limit;
double turnover_time_sum, weighted_turnover_time_sum;

struct JCB
{
    int index; //作业序号
    string name; //作业名称
    string state; //状态
    int estimate_time; //预计运行时间
    int arrive_time; //到达时间
    int running_time; //实际运行时间
    int end_time; //结束时间
    inline int turnover_time()const //周转时间
    {
        return cur_time-arrive_time;
    }
    inline double weighted_turnover_time()const
    {
        return turnover_time()*1.0/running_time;
    }
    inline int waiting_time()const //等待时间
    {
        return turnover_time()-running_time;
    }
    inline double response_ratio()const //响应比
    {
        return (waiting_time()+estimate_time)*1.0/estimate_time;
    }

    void print()const
    {
        printf("作业 %d : \t",index);
        cout<<"|名称: "<<name<<" \t";
        cout<<"|状态: "<<state<<" \t";
        printf("|到达: %d \t",arrive_time);
        printf("|预计运行: %d \t",estimate_time);
        printf("|已运行: %d \t",running_time);
        printf("|已等待: %d \t",waiting_time());
        if(state=="reserve")
        {
            printf("|响应比: %.2f",response_ratio());
        }
        if(state=="destroy")
        {
            printf("|周转时间: %d \t",turnover_time());
            printf("|带权周转: %.2f",weighted_turnover_time());
        }
        printf("\n");
    }
    bool operator>(const JCB &o)const
    {
        return response_ratio()>o.response_ratio();
    }
};
bool cmp(const JCB &a,const JCB &b)
{
    return a.arrive_time<b.arrive_time;
}

vector<JCB> memory; //内存
vector<JCB> rq; //后备队列
vector<JCB> destroy; //待销毁

JCB createJob(int index) //创建
{
    JCB res;

    printf("\n\n作业序号: %d\n",res.index=index);
    res.state="reserve";

    printf("请输入作业名称:\n");
    cin>>res.name;

    printf("请输入预计运行时间:\n");
    cin>>res.estimate_time;

    printf("请输入到达时间:\n");
    cin>>res.arrive_time;

    res.running_time=0;

    return res;
}

void printJobs() //输出各个作业情况
{
    printf("\n************************************************************\n");
    printf("目前时间: %d\n",cur_time);

    printf("\n内存中存在 %d 个作业:\n",memory.size());
    for(auto job:memory) job.print();

    printf("\n后备队列中存在 %d 个作业:\n",rq.size());
    for(auto job:rq) job.print();

    printf("\n待销毁 %d 个作业:\n",destroy.size());
    for(auto job:destroy) job.print();

    cout<<endl<<endl<<endl<<endl;
}

void runJobs() //运行内存中的作业
{
    for(unsigned int i=0;i<memory.size();i++)
    {
        memory[i].running_time++;
        if(memory[i].running_time==memory[i].estimate_time)
        {
            memory[i].state="destroy";
            memory[i].end_time=cur_time;
            destroy.push_back(memory[i]);
            memory.erase(memory.begin()+i);
            i--;
        }
    }
}

JCB findJobs() //在后备队列查找作业
{
    unsigned int idx=0;
    for(unsigned int i=1;i<rq.size();i++)
    {
        if(rq[i]>rq[idx]) idx=i;
    }
    printf("调度该作业进入内存:\n");
    rq[idx].print();
    JCB res=rq[idx];
    res.state="running";
    rq.erase(rq.begin()+idx);
    return res;
}

void destroyJobs() //销毁待销毁的作业
{
    for(unsigned int i=0;i<destroy.size();i++)
    {
        turnover_time_sum+=destroy[i].turnover_time();
        weighted_turnover_time_sum+=destroy[i].weighted_turnover_time();
    }
    destroy.clear();
}


int main()
{
    printf("请输入内存允许的最多作业数目:\n");
    cin>>limit;

    printf("请输入作业总数目:\n");
    int num; cin>>num;

    vector<JCB> 
                       
                    
                     
                      



鲜花




握手




雷人




路过




鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期

11-06 可心卡盟:win10系统火狐flash插件崩溃怎么

11-06 亲亲特价:怎么删除回收站图标

11-06 济南大学虚拟社区:鲁大师节能降温的具体办

11-06 xlueops.exe:无线网络安装向导

11-06 女斗合众国:win7系统cf与主机连接不稳定怎

11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头

11-06 qizideyouhuo:应用程序无法正常启动0xc0000

11-06 ipz-185:win7系统vcf文件怎么打开

11-06 傻哥蹦迪:win10系统s4怎么打开usb调试

11-06 八神浩树gtaste:回收站清空了怎么恢复

11-06 妖尾之黑色守护:win10系统电脑没有1440x900

11-06 校园至尊魔王小说:win7系统浏览网页时字体

11-06 女斗合众国:win10系统访问共享文件夹提示请

11-06 tokyo hot n0654:恢复win7系统默认字体一招

11-06 雨酷仙境:设置win7系统转移临时文件夹腾出

11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原

11-06 tunespotting:win10系统火狐flash插件总是

11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什

11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密

11-06 博益网首页:ao3网页版进入不了解决方法

11-06 漏斗子专栏: 网站数据分析小白易懂精华篇

11-06 见证双虹怎么做:win7系统开启telnet命令的

11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务

11-06 国光中学校歌:提交网站到alexa查询详细步骤

11-06 西安有情天:静态网页和动态网页的区别

11-06 红木雅尚斋:外部链接构造对网站的好处

11-06 前官礼遇：防止域名劫持–增强域安全性的10

11-06 密传二转答案: 中文分词算法有哪些

11-06 金泉家园邮编:百度快照劫持的表现及应对方

windows系统中weblogic12c创建域发布时间：2022-07-13

C#编写简单的聊天程序发布时间：2022-07-13

剪的笔顺,诠释剪的笔画,认识剪的部首

六六分期app的软件客服如何联系？(六六分期

2023-10-27

florent37/ViewAnimator: A fluent Android

2022-08-15

florent37/Shrine-MaterialDesign2: implem

2022-08-17

CVE-2020-36276

2022-09-23

SimpleSoftwareIO/simple-sms: Send and re

2022-08-13

阅读排行榜

1 六六分期app的软件客服如何联系？(六六分期

六六分期app的软件客服如何联系？不知道吗？加qq群【895510560】即可！标题：六六分期

阅读：19190|2023-10-27

2 可心卡盟:win10系统火狐flash插件崩溃怎么

今天小编告诉大家如何处理win10系统火狐flash插件总是崩溃的问题，可能很多用户都不知

阅读：9988|2022-11-06

3 亲亲特价:怎么删除回收站图标

今天小编告诉大家如何对win10系统删除桌面回收站图标进行设置，可能很多用户都不知道

阅读：8326|2022-11-06

4 济南大学虚拟社区:鲁大师节能降温的具体办

今天小编告诉大家如何对win10系统电脑设置节能降温的设置方法，想必大家都遇到过需要

阅读：8696|2022-11-06

5 xlueops.exe:无线网络安装向导

我们在使用xp系统的过程中,经常需要对xp系统无线网络安装向导设置进行设置，可能很多

阅读：8639|2022-11-06

6 女斗合众国:win7系统cf与主机连接不稳定怎

今天小编告诉大家如何处理win7系统玩cf老是与主机连接不稳定的问题，可能很多用户都不

阅读：9657|2022-11-06

7 0xc000022-[cf烟雾头]cf怎么调烟雾头

电脑对日常生活的重要性小编就不多说了，可是一旦碰到win7系统设置cf烟雾头的问题，很

阅读：8624|2022-11-06

8 qizideyouhuo:应用程序无法正常启动0xc0000

我们在日常使用电脑的时候，有的小伙伴们可能在打开应用的时候会遇见提示应用程序无法

阅读：7998|2022-11-06

9 ipz-185:win7系统vcf文件怎么打开

今天小编告诉大家如何对win7系统打开vcf文件进行设置，可能很多用户都不知道怎么对win

阅读：8656|2022-11-06

10 傻哥蹦迪:win10系统s4怎么打开usb调试

今天小编告诉大家如何对win10系统s4开启USB调试模式进行设置，可能很多用户都不知道怎

阅读：7535|2022-11-06

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服

地址：深圳市南山区西丽大学城创智工业园

电邮：jeky_zhao#qq.com

移动电话：139-2527-9053

客服电话

电子邮件

若干简单的进程和作业调度的C++模拟程序

进程调度（时间片轮转，动态优先级，链表形式）：

作业调度（FCFS调度）：

作业调度（SJF调度）：

作业调度（HRRN调度）：

请发表评论

全部评论

上一篇：

下一篇：

bradtraversy/iweather: Ionic 3 mobile we

joaomh/curso-de-matlab

断牙刷新位置时间（断牙属性及刷新位置介绍

rugk/mastodon-simplified-federation: Sim

PureSwift/BluetoothLinux: Pure Swift Lin