1. 操作系统模拟电梯调度算法C语言程序
这是数学建模的题目，太难了。
只能给点提示，希望有用。一，用到随机函数。二，调度算法为FIFO和电梯调度。参考操作系统。三，文件io用到#include
<fstream>头文件
2. 操作系统-cpu调度算法设计
对等动态优先权算法，进程调度过程掌握情况；考查学生的写算法和编程能力等；考查学生的分析问题和解决问题的能力；实验报告的撰写能力等。 设计思路： （1）先对就绪队列，阻塞队列，cpu的进行初始化。 （2）进行进程调度的选择。 1）cpu，就绪...
3. 实时操作系统常用任务调度算法有哪些
实时操作系统常用任务调度算法有哪些
操作系统常用的批处理作业调度算法
1．先来先服务调度算法
先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
2．短作业(进程)优先调度算法
4. 操作系统优先级调度算法怎么样用c的实现谢谢了，大神帮忙啊
进程调度源程序如下： jingchendiao.cpp #include "stdio.h" #include <stdlib.h> #include <conio.h> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 struct pcb { /* 定义进程控制块PCB */ char name[10]; char state; int super; int ntime; int rtime; struct pcb* link; }*ready=NULL,*p; typedef struct pcb PCB; sort() /* 建立对进程进行优先级排列函数*/ { PCB *first, *second; int insert=0; if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ { p->link=ready; ready=p; } else /* 进程比较优先级,插入适当的位置中*/ { first=ready; second=first->link; while(second!=NULL) { if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ { /*插入到当前进程前面*/ p->link=second; first->link=p; second=NULL; insert=1; } else /* 插入进程优先数最低,则插入到队尾*/ { first=first->link; second=second->link; } } if(insert==0) first->link=p; } } input() /* 建立进程控制块函数*/ { int i,num; clrscr(); /*清屏*/ printf("\n 请输入进程号?"); scanf("%d",&num); for(i=0;i<num;i++) { printf("\n 进程号No.%d:\n",i); p=getpch(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函数*/ } } int space() { int l=0; PCB* pr=ready; while(pr!=NULL) { l++; pr=pr->link; } return(l); } disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ { printf("\n qname \t state \t super \t ndtime \t runtime \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"); } check() /* 建立进程查看函数 */ { PCB* pr; printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p); pr=ready; printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/ while(pr!=NULL) { disp(pr); pr=pr->link; }
5. （操作系统）编写进程调度算法程序
#include<iostream>
#include<string>
#include<iomanip>
#include<windows.h>
using namespace std;
typedef struct Process
{ string id;
int arrive_time;
int sever_time;
int finish_time;
int turnover_time;
Process * next;
}Process,* Linkp; class FCFS_schele
{ public: FCFS_schele()
{
Creat_queue();
}
~FCFS_schele();
void Creat_queue();
void Insert_queue();
void orderInsert_queue();
void Out_queue();
void Printall();
void Sort_queue();
Process Gethead();
private:
Linkp head,tail;
int num;
Process Creat_process();
};///////////////////////////////////////////////////////方法的具体实现void FCFS_schele::Creat_queue()
{ head=new Process;
head->next=0;
tail=head;
num=0;
}
ostream& operator <<(ostream& out,Process& a) //对插入流运算符<<进行重载
{ out<<"process id:"<<a.id <<" arrivetime:"<<a.arrive_time
<<" severtime:"<<a.sever_time<<endl;
return(out);
}Process FCFS_schele::Creat_process()
{ Process a;
cout<<"please input process id"<<num+1<<":";
cin>>a.id ;
cout<<"please input process arrivetime:";
cin>>a.arrive_time ;
cout<<"please input process severtime:";
cin>>a.sever_time ;
a.finish_time=0;
a.turnover_time=0;
a.next =0;
return(a);
} void FCFS_schele::Insert_queue ()
{ Linkp p;
p=new Process;
*p=Creat_process();
if(num==0)
{p->finish_time=p->arrive_time+p->sever_time;<br> p->turnover_time=p->finish_time-p->arrive_time ;<br> }
else
{p->finish_time=tail->finish_time + p->sever_time ;<br> p->turnover_time=p->finish_time - p->arrive_time ;<br> }
tail->next=p;
tail=p;
num++;
}
void FCFS_schele::Out_queue() //进程调度出队
{ Linkp p;
p=head->next;
if(!p) cout<<"empty!\n";
else
{ head->next=p->next;
if(p->next==NULL) tail=head;
cout<<"process id:"<<p->id<<" arrivetime:"<<p->arrive_time
<<" severtime:"<<p->sever_time<<" finishtime:"<<p->finish_time
<<" turnovertime:"<<p->turnover_time <<endl;
delete p;
num--;
}
}
Process FCFS_schele::Gethead()throw(int)
{ Linkp p;
p=head->next;
if(p) return(*p);
else throw 1; //当队空无法返回Process类型返回值时抛出异常错误整形值1
}
void FCFS_schele::Printall()
//打印进程队列所有进程信息
{ Linkp p;
float sum_wghtime=0;
p=head->next;
cout<<" Process Information\n";
cout<<"process id arrivetime severtime finishtime turnovertime weightime\n";
while(p)
{ cout<<p->id<<setw(14)<<p->arrive_time
<<setw(14)<<p->sever_time<<setw(14)<<p->finish_time<<setw(14)<<p->turnover_time
<<setw(14)<<float(p->turnover_time)/float(p->sever_time )<<endl;
sum_wghtime=sum_wghtime+(float)p->turnover_time/p->sever_time;
p=p->next;
}
cout<<"平均带权周转时间为:"<<sum_wghtime/num<<endl;
}
void FCFS_schele::Sort_queue ()
//采用选择法将队列中的进程按servertime长短进行换值不换址的排序{ Linkp location,search,record,track;
Process temp;
track=head->next;
location=track->next ;
while(location && location->next )
{ record=search=location;
while(search)
{ if(search->sever_time <record->sever_time ) record=search;
search=search->next ;
} if(record!=location)
{
temp=*record;
record->arrive_time =location->arrive_time ;
record->id =location->id ;
record->sever_time =location->sever_time ;
location->id =temp.id;
location->sever_time =temp.sever_time ;
location->arrive_time =temp.arrive_time ;
location->finish_time =track->finish_time + location->sever_time ;
location->turnover_time =location->finish_time - location->arrive_time ;
}
track=location;
location=location->next ;
}
if(tail==location)
{tail->finish_time = track->finish_time +tail->sever_time ;<br> tail->turnover_time =tail->finish_time -tail->arrive_time ;<br> }}
FCFS_schele::~FCFS_schele ()
{ Linkp p;
while(p=head)
{
head=head->next ;
delete p;
}
cout<<"the storage of memory has been distory!\n";
} void FCFS_schele::orderInsert_queue () //进程插入排序
{ Linkp p,pr;
p=new Process;
*p=Creat_process(); if(num==0)
{
head->next=p;
tail=p;
p->finish_time =p->arrive_time + p->sever_time ;
p->turnover_time =p->finish_time - p->arrive_time ;
}
else
{
pr=head->next ;
while(pr->next && p->sever_time >= pr->next->sever_time )
pr=pr->next;
if(pr->next==0)
{
p->finish_time = tail->finish_time + p->sever_time ;
p->turnover_time =p->finish_time - p->arrive_time ;
tail->next=p;
tail=p;
}
else
{
p->next =pr->next ;
pr->next=p;
while(p)
{
p->finish_time =pr->finish_time + p->sever_time ;
p->turnover_time = p->finish_time - p->arrive_time ;
pr=p;
p=p->next ;
}
}
}
num++;
} void main()
{
// DWORD start=GetTickCount();
FCFS_schele os;
os.orderInsert_queue ();
os.orderInsert_queue ();
os.orderInsert_queue ();
os.orderInsert_queue ();
os.orderInsert_queue ();
// os.orderInsert_queue ();
// os.orderInsert_queue ();
os.Printall ();
// os.Sort_queue ();
os.Sort_queue ();
os.Printall ();
os.Out_queue ();
os.Out_queue ();
os.Out_queue ();
os.Out_queue ();
/* try{
cout<<os.Gethead () ;
}
catch(int i)
{ if(i==1) cout<<"empty!\n";
}*/
//
// DWORD end=GetTickCount();
// cout<<"spend time:"<<(end-start)<<endl;
/*
os.Out_queue ();
*/
}
6. 急求一个用C或C++写的关于操作系统 调度问题的代码（FCFS和SJF调度算法）
你们这个是操作系统的作业吧。
记得我们上学的时候就是这个。
7. 操作系统的调度算法
1)10:00Job1到达并投入运行。此时内存中有作业:Job1
2)10:05 Job2到达并进入内存。此时，Job1运行时间剩余是25min， Job2运行剩余时间是20min，根据SRTF，Job2开始运行。
3)10:25 Job2运行结束。Job3、Job4在后备队列中，据SJF，Job3进入内存，据SRTF，Job3开始运行。内存：Job1、Job3
4)10:30 Job3运行结束。Job4在后备队列中，Job4进入内存，据SRTF，Job4开始运行。内存：Job1、Job4
5)10:40 Job4运行结束。Job1重新继续运行。
6)11:05 Job1运行结束。
8. 急求 程序代码 c/c++ 操作系统中的 处理机调度算法
#include <iostream>
#include <stdio.h>
#include <string>
//#include <windows.h>
using namespace std;
//hyugtyftydrtdtrdrrtrdrt
struct Node
{
string name;//进程（作业）名称
int arriveTime;//到达时间
int ServerTime;//服务时间
int leftTime;//the left time
Node *link;//指向下一个节点的指针
};
class CProcess
{
public:
CProcess();//构造函数
~CProcess();//析构函数
const CProcess &operator =(const CProcess& p);//重载赋值操作符
void insertNode(string &na,int& at,int& st);//插入新元素（at由小到大）到链表合适的位置
void sort();//按照服务时间由大到小排序
bool isEmpty();//判断是否为空
void destroy();//销毁
int length();//求出链表长度
void print();//打印出元素
void FCFS();//先到先服务
void SJF();//短进程(作业)优先
void RR(int& q);//时间片轮转
void priority();//优先权调度
protected:
Node *first;
Node *last;
};
const CProcess& CProcess::operator=(const CProcess& p)
{
Node *newNode;
Node *Current;
if(this!=&p)//避免自己给自己赋值
{
if(first!=NULL)//如果链表不为空
destroy();
if(p.first==NULL)
{//如果要拷贝的对象为空
this->first = NULL;
this->last = NULL;
}
else
{
Current = p.first;
first= new Node;
first->name=Current->name;//
first->arriveTime=Current->arriveTime;
first->ServerTime=Current->ServerTime;
first->link =NULL;
last =first;
Current = Current->link;
while(Current!=NULL)
{
newNode = new Node;
newNode->name=Current->name;
newNode->arriveTime=Current->arriveTime;
newNode->ServerTime=Current->ServerTime;
newNode->link=NULL;
last->link=newNode;
last=newNode;
Current = Current->link;
}
}
}
return *this;
}
CProcess::CProcess()
{//构造函数
first=NULL;
last=NULL;
}
CProcess::~CProcess()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::insertNode(string &na,int& at,int& st)
{//按照到达时间升序排序
Node *Current;
Node *trailCurrent;//指向Current的前一个节点
Node *newNode;
bool found;
newNode = new Node;//建立一个新节点
newNode->name=na;
newNode->arriveTime=at;
newNode->ServerTime=st;
newNode->link=NULL;//
if(first==NULL)//如果第一个节点为空（如果是第一次插入元素）
first=newNode;//将新节点赋给第一个节点
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL && !found)
{
if(Current->arriveTime >= at)
found = true;
else
{
trailCurrent = Current;
Current = Current->link;
}
}
if(Current==first)
{
newNode->link = first;
first = newNode;
}
else
{
trailCurrent->link = newNode;
newNode->link = Current;
}
}
}
int CProcess::length()
{
int count =0;//声明变量，并初始化为0（用来记录长度）
Node *Current;
Current = first;
while(Current!=NULL)//当前节点不为空，记录值自加，一直向后遍历,
{
count++;
Current = Current->link;
}
return count;//返回长度
}
void CProcess::sort()//按照服务时间，升序排列
{//冒泡排序
string sname;
int at;
int st;
Node *Current;//指向当前节点
Node *trailCurrent;//指向当前节点的前一个节点
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制条件有问题
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制条件有问题
{
if(trailCurrent->ServerTime > Current->ServerTime)
{
sname=trailCurrent->name;
at=trailCurrent->arriveTime;
st=trailCurrent->ServerTime;
trailCurrent->name=Current->name;
trailCurrent->arriveTime=Current->arriveTime;
trailCurrent->ServerTime=Current->ServerTime;
Current->name=sname;
Current->arriveTime=at;
Current->ServerTime=st;
}
}
}
}
bool CProcess::isEmpty()//判断是否为空
{
return (first==NULL);//如果第一个节点为空，返回值
}
void CProcess::print()
{
Node *Current;
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)//当前节点不为空，一直向后遍历打印
{
cout<<Current->name<<" ";
cout<<Current->arriveTime<<" ";
cout<<Current->ServerTime<<"\n";
Current = Current->link;
}
}
void CProcess::destroy()
{
Node *temp;//定义一个临时指针变量
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::FCFS()//先到先服务
{
Node *Current;
int T0=0;//完成时间
int T1=0;//周转时间
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周转时间等于，完成时间 - 到达时间
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
}
}
void CProcess::SJF()//短进程(作业)优先
{
//首先执行第一个到达的作业
Node *Current;
int T0=0;//完成时间
int T1=0;//周转时间
T0=first->link->ServerTime+T0;
T1=T0-first->link->arriveTime;
cout<<first->link->name<<"\t";
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
first->link=first->link->link;//删除
//执行剩下的
sort();//对剩下的排序
Current = first->link;//头节点赋给当前节点
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周转时间等于，完成时间 - 到达时间
cout<<Current->name<<"\t";//打印出进程名
cout<<T0<<"\t";//打印出完成时间
cout<<T1<<"\n";//打印出周转时间
Current = Current->link;
}
}
}
void CProcess::RR(int& q)//时间片轮转
{
cout<<"时间片轮转操作完成！\n";
}
void CProcess::priority()//优先权调度
{
cout<<"优先权操作完成！\n";
}
void main()
{
CProcess p0,p1,p2,p3,p4;
int at,st;
string na;
int judge=1;//控制退出程序
int choice;//控制选择操作
while(judge)
{
cout<<"********************************************************\n";
cout<<"****** 说明：本程序适用于单道进程（作业） ******\n";
cout<<"******** 请选择您的操作 ***************\n";
cout<<"*********输入相应的数字，按下（Enter）键！**************\n";
cout<<"************* 5.录入信息 ************\n";
cout<<"************* 1.先到先服务 ************\n";
cout<<"************* 2.短进程（作业）优先 ************\n";
cout<<"************* 3.时间片轮转 ************\n";
cout<<"************* 4.优先权(静态)调度 ************\n";
cout<<"************* 0.退出程序 ************\n";
cout<<"********************************************************\n";
cin>>choice;
switch(choice)
{
case 0:
judge=0;
break;
case 5:
cout<<"请输入信息以“end”结束输入！\n";
cout<<"进程名 到达时间 服务时间"<<endl;
while(na.compare("end"))//如果相等则会返回0
{
p0.insertNode(na,at,st);
cin>>na>>at>>st;
}
cout<<"录入成功，目前的信息为：\n";
cout<<"进程名 到达时间 服务时间"<<endl;
p0.print();
break;
case 1://先到先服务
p1=p0;//拷贝一份
if(p1.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"先到先服务\n";
cout<<"进程名 完成时间 周转时间\n";
p1.FCFS();
break;
}
case 2://短作业优先
p2=p0;//拷贝一份
//p2.sort();
//p2.print();
if(p2.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"短作业优先\n";
cout<<"进程名 完成时间 周转时间\n";
p2.SJF();
break;
}
case 3://时间片轮转
p3=p0;//拷贝一份
int q;
if(p3.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"请输入时间片大小";
cin>>q;
cout<<"时间片轮转\n";
cout<<"进程名 完成时间 周转时间\n";
p3.RR(q);
break;
}
case 4://优先权
p4=p0;//拷贝一份
if(p4.isEmpty())
{
cout<<"请先录入信息\n";
break;
}
else
{
cout<<"时间片轮转\n";
cout<<"进程名 完成时间 周转时间\n";
p4.priority();
break;
}
default:
cout<<"请选择目录中的选项！\n";
break;
}
}
return;
}
9. 急求操作系统“处理机调度算法”的课程设计的代码，要用C++或者JAVA，要能编译运行
以LAMP兄弟连的课程安排来说主要学习一下内容：
1.SpringSecurity：目前最主流的JavaEE安全解决方案，基于Spring。为基于JavaEE企业开发提供全面安全服务。
2.WebSphere：企业级应用服务器。包含了编写、运行和监视全天候的工业强度的随需应变 Web应用程序和跨平台、跨产品解决方案所需要的整个中间件基础设施。
3.负载均衡：高并发解决方案。能利用一个集群中的多台单机，响应更多的并发请求。
4.分布式系统：由网络互联的多处理机体系结构上执行任务的系统。可有效提高系统的可扩展性、稳定性和执行效率
10. 求一个操作系统处理机调度先来先服务算法的代码，急，要C++的
没财富回答个吊