Question

进程调度算法模拟程序设计

用C语言（或其它语言，如Java）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
 进程标识数ID。
 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
 进程已占用CPU时间CPUTIME。
 进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。
 进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
 进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
 进程状态STATE。
 队列指针NEXT，用来将PCB排成队列。
优先数改变的原则：
 进程在就绪队列中呆一个时间片，优先数增加1。
 进程每运行一个时间片，优先数减3。
为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。

Answer 1

public class PrivilegeProcess {
public static void main(String[] args) {
MyQueue myqueue = new MyQueue();//声明队列
PCB[] pcb = {new PCB(001,8,1),new PCB(002,7,9),new PCB(003,3,8),new PCB(004,1,7),new PCB(005,7,4)};
PCB para = new PCB();
for(int i=0;i<pcb.length;i++){//初始化后首先执行一次排序，这里使用的是选择排序，优先级高的先入队
for(int j=i;j<pcb.length;j++){
if(pcb[i].privilege < pcb[j].privilege){
para = pcb[i];
pcb[i] = pcb[j];
pcb[j] = para;
}
}
}
System.out.println("初次入队后各进程的顺序：");
for(int i=0;i<pcb.length;i++){
System.out.println("初次入队后 # processname : " + pcb[i].name + " totaltime : " + pcb[i].totaltime + " privilege :" + pcb[i].privilege);
}
System.out.println();
myqueue.start(pcb);
}
}

class MyQueue {
int index = 0;
PCB[] pc = new PCB[5];
PCB[] pc1 = new PCB[4];
PCB temp = new PCB();

public void enQueue(PCB process){//入队算法
if(index==5){
System.out.println("out of bounds !");
return;
}
pc[index] = process;
index++;
}

public PCB deQueue(){//出队算法
if(index==0)
return null;
for(int i=0;i<pc1.length;i++){
pc1[i] = pc[i+1];
}
index--;
temp = pc[0];
for(int i=0;i<pc1.length;i++){
pc[i] = pc1[i];
}
return temp;
}

public void start(PCB[] pc){//显示进程表算法
while(pc[0].isNotFinish==true||pc[1].isNotFinish==true||pc[2].isNotFinish==true||pc[3].isNotFinish==true||pc[4].isNotFinish==true){
//*注意：||运算符，所有表达式都为false结果才为false,否则为true
for(int i=0;i<pc.length;i++){
pc[i].run(this);
}
System.out.println();
for(int i=0;i<pc.length;i++){//所有进程每执行完一次时间片长度的运行就重新按优先级排列一次
for(int j=i;j<pc.length;j++){
if(pc[i].privilege < pc[j].privilege){
temp = pc[i];
pc[i] = pc[j];
pc[j] = temp;
}
}
}
}
}
}

class PCB {//声明进程类
int name,totaltime,runtime,privilege;
boolean isNotFinish;

public PCB(){

}

public PCB(int name, int totaltime, int privilege){
this.name = name;//进程名
this.totaltime = totaltime;//总时间
this.privilege = privilege;//优先级别
this.runtime = 2;//时间片，这里设值为2
this.isNotFinish = true;//是否执行完毕
System.out.println("初始值： processname : " + name + " totaltime : " + totaltime + " privilege :" + privilege );
System.out.println();
}

public void run (MyQueue mq){//进程的基于时间片的执行算法
if(totaltime>1){
totaltime-=runtime;//在总时间大于1的时候，总时间=总时间-时间片
privilege--;
System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege );
}else if(totaltime==1){
totaltime--;//在总时间为1时，执行时间为1
privilege--;
System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege );
}else{
isNotFinish = false;//总时间为0，将isNotFinish标记置为false
}
if(isNotFinish==true){
mq.deQueue();
mq.enQueue(this);
}
}
}

Answer 2

#include <iostream>
using namespace std;
#include <string>
typedef struct pcb
{
string name;
int number;
int ntime;
int runtime;
int priority;
} PCB,*PPCB;
void Input(PPCB p,int num);
void Sort(PPCB p , int num);
bool RunOnce(PPCB p,int num);
int main ()
{
PPCB p;
int num;
cout<<"请输入要执行的进程个数:";
cin>>num;
p = new PCB[num];
Input(p,num);
bool bRun = true;
while (bRun)
{
bRun = RunOnce(p,num);
if (p[num-1].ntime == 0)
num --;
system("pause");
}
return 0;
}
bool RunOnce(PPCB p,int num)
{
for (int i = 0 ; i < num ; i ++)
{
if (i == 0)
{
p[i].runtime++;
p[i].ntime--;
cout<<"运行进程\n";
cout<<"进程名称\t进程号\t\t需要时间\t运行时间\t优先级\n";
cout<<p[i].name<<"\t\tNO."<<p[i].number<<"\t\t"<<p[i].ntime<<"\t\t"<<p[i].runtime<<"\t\t"<<p[i].priority<<"\n";
p[i].priority--;
if (p[i].ntime <= 0)
{
p[i].priority = 0;
}
cout<<"\n就绪队列\n";
cout<<"进程名称\t进程号\t\t需要时间\t运行时间\t优先级\n";
}
else
{
cout<<p[i].name<<"\t\tNO."<<p[i].number<<"\t\t"<<p[i].ntime<<"\t\t"<<p[i].runtime<<"\t\t"<<p[i].priority<<"\n";
}

}
Sort(p,num);
if (p[0].ntime <= 0)
return false;
else
return true;
}
void Input(PPCB p,int num)
{
for (int i = 0 ; i < num ; i ++)
{
p[i].number = i+1;
cout<<"进程号: NO"<<p[i].number<<"\n进程名:";
cin>>p[i].name;
cout<<"需要时间:";
cin>>p[i].ntime;
p[i].runtime = 0;
cout<<"优先级:";
cin>>p[i].priority;
}
cout<<"进程名称\t进程号\t\t需要时间\t运行时间\t优先级\n";
for (i = 0 ; i < num ; i ++)
{
cout<<p[i].name<<"\t\tNO."<<p[i].number<<"\t\t"<<p[i].ntime<<"\t\t"<<p[i].runtime<<"\t\t"<<p[i].priority<<"\n";
}
Sort(p,num);
}

void Sort(PPCB p , int num){
int i,j,temp;
string str;
for(i = 0 ; i < num - 1; i++)
{
for(j = num - 1 ; j > i; j--)
{
if (p[j].priority > p[j - 1].priority)
{
str = p[j].name;
p[j].name = p[j - 1].name;
p[j - 1].name = str;

temp = p[j].ntime;
p[j].ntime = p[j - 1].ntime;
p[j - 1].ntime = temp;

temp = p[j].number;
p[j].number = p[j - 1].number;
p[j - 1].number = temp;

temp = p[j].priority;
p[j].priority = p[j - 1].priority;
p[j - 1].priority = temp;

temp = p[j].runtime;
p[j].runtime = p[j - 1].runtime;
p[j - 1].runtime = temp;
}
}
}
}

Answer 3

这么有技术含量的问题，应该要更有技术含量的回答，你给个30分悬赏，高手都不睬你~！

Answer 4

网页链接里面有java编译 进程调度算法 详细代码，可以输出结果并且绘制折线图