进程调度(时间片轮转,动态优先级,链表形式):

#include<cstdio>
#include<cstdlib> struct PCB
{
char name[];
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=;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=;
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=;
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 ;
} /*
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=; 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=;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=;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=;i<num;i++) tmp.push_back(createJob(i));
sort(tmp.begin(),tmp.end(),cmp); cur_time=;
turnover_time_sum=weighted_turnover_time_sum=0.0;
while(tmp.size()> || fifo.size()> || memory.size()>)
{
while(memory.size()<limit && fifo.size()>)
{
JCB tmp=fifo.front();
fifo.pop();
tmp.state="running";
memory.push_back(tmp);
} for(unsigned int i=;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=; 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=;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=;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=;i<num;i++) tmp.push_back(createJob(i));
sort(tmp.begin(),tmp.end(),cmp); cur_time=;
turnover_time_sum=weighted_turnover_time_sum=0.0;
while(tmp.size()> || heap.size()> || memory.size()>)
{
//将若干作业调度运行
while(memory.size()<limit && heap.size()>)
{
JCB tmp=heap.top(); heap.pop();
tmp.state="running";
memory.push_back(tmp);
} //当前时间点到达的作业进入后备队列
for(unsigned int i=;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=; 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=;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=;
for(unsigned int i=;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=;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=;i<num;i++) tmp.push_back(createJob(i));
sort(tmp.begin(),tmp.end(),cmp); cur_time=;
turnover_time_sum=weighted_turnover_time_sum=0.0;
while(tmp.size()> || rq.size()> || memory.size()>)
{
//将若干作业调度运行
while(memory.size()<limit && rq.size()>)
memory.push_back(findJobs()); //当前时间点到达的作业进入后备队列
for(unsigned int i=;i<tmp.size();i++)
{
if(tmp[i].arrive_time==cur_time)
{
rq.push_back(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
*/

若干简单的进程和作业调度的C++模拟程序的更多相关文章

  1. Windows 下针对python脚本做一个简单的进程保护

    前提: 大家运行的脚本程序经常会碰到系统异常关闭.或被其他用户错杀的情况.这样就需要一个进程保护的工具. 本文结合windows 的计划任务,实现一个简单的进程保护的功能. 利用py2exe生产 ex ...

  2. SSDT Hook实现简单的进程隐藏和保护【转载】

    原文链接:http://www.blogfshare.com/ssdthook-hide-protect.html 原文作者:AloneMonkey SSDT Hook实现简单的进程隐藏和保护 Alo ...

  3. mschedule 简单linux进程管理(树莓派)

    树莓派是神奇的机器,CPU和内存都少的可怜,但体积小功耗低,在上面搞些动搞些西其实也挺有意思,挺好玩的.装的是pidara,基本服务没有精简多少,先cat一下CPU和RAM. [able@raspi ...

  4. APP中一种在Java层实现的简单守护进程方式

    转载请把头部出处链接和尾部二维码一起转载,本文出自逆流的鱼yuiop:http://blog.csdn.net/hejjunlin/article/details/52779986 守护进程是一个黑色 ...

  5. Linux下一个简单守护进程的实现 (Daemon)

    在Linux/UNIX系统引导的时候会开启很多服务,这些服务称为守护进程(也叫Daemon进程).守护进程是脱离于控制终端并且在后台周期性地执行某种任务或等待处理某些事件的进程,脱离终端是为了避免进程 ...

  6. windows简单杀死进程的批处理程序

    新建一个txt文档,命令为taskkill.bat,复制下面的命令保存 @echo offtaskkill /F /IM vm* /Ttaskkill /F /IM apple* /Ttaskkill ...

  7. Linux基础-简单的进程操作

    任务:查找一个名为firewall的进程,并且将其强制杀死 首先要使用ps -aux来查询firewall的进程ID(|grep firewall) 这样我们就得到了firewall的进程ID是653 ...

  8. Linux-编写简单守护进程

    1.任何一个进程都可以将自己实现成一个守护进程 2.create_daemon函数要素 (1).子进程要等待父进程退出 (2).子进程使用setsid创建新的会话期,脱离控制台 (3).调用chdir ...

  9. linux 进程监控和自动重启的简单实现

    目的:linux 下服务器程序会因为各种原因dump掉,就会影响用户使用,这里提供一个简单的进程监控和重启功能. 实现原理:由定时任务crontab调用脚本,脚本用ps检查进程是否存在,如果不存在则重 ...

随机推荐

  1. 异地协作,A地上传jar包到B地服务器上传速率慢

    在A地使用ftp服务器,再登录B地的目标服务器,使用ftp命令从ftp服务器下载文件,速度快点,下载带宽比上传带宽要大一点 https://blog.csdn.net/df0128/article/d ...

  2. 【c# 学习笔记】接口

    一.什么是接口 接口 可以理解为对一组方法声明进行的同一命名,但这些方法没有提供任何实现.也就是说,把一组方法声明在一个接口中,然后继承于该接口的类都 需要实现这些方法. 例如,很多类型(比如int ...

  3. IdentityServer4学习笔记汇总(实现传送门在底部)

    前言 互联网时代,对信息和资源的保护越发苛刻,在所有应用中授权和认证是必不可少缺少的一部分.如果一个应用没有授权和认证那么这个应用就是不完整或者说不安全的应用.在.Net平台给我们提供了一套完整的授权 ...

  4. Asp.Net文件的上传和下载

    aspx页面: <%@ Page Language="C#" AutoEventWireup="true" CodeFile="上传和下载文件. ...

  5. nginx静态资源设置缓存的方法

    nginx静态资源设置缓存的方法 直接加expires 30d; 就是就可以了 缓存时间30天完整如下 <pre> location / { root /home/www/wordpres ...

  6. Spring boot+Websocket实例1

    简单的demo https://github.com/callicoder/spring-boot-websocket-chat-demo

  7. ConcurrentHashMap能完全替代HashTable吗?

    至此你应该能够明白,ConcurrentHashMap与HashTable都可以用于多线程的环境,但是当Hashtable的大小增加到一定的时候,性能会急剧下降,因为迭代时需要被锁定很长的时间.因为C ...

  8. [NOIP普及组2011]装箱问题

    目录 链接 博客链接 题目链接 题目内容 题目描述 格式 输入 输出 样例 输入 输出 前缀知识 题解 题目名称:装箱问题 来源:2011年NOIP普及组 链接 博客链接 CSDN 洛谷博客 题目链接 ...

  9. msql 数据类型

    1.数据类型 #1. 数字: 整型:tinyinit int bigint 小数: float :在位数比较短的情况下不精准 double :在位数比较长的情况下不精准 0.0000012301231 ...

  10. 并不对劲的THUWC2020

    day -inf 因为一些(不是寒假时长锐减的)小原因,今年(2020)THUWC在去年(2019)就举办了! 这导致某个小弱智只能临阵磨枪了QAQ- day 1 早: 没有看到吕爷,签到.试机. 签 ...