实验一:处理机调度仿真(10学时)

1. 实验内容:

   在处理机三级调度系统中，编程仿真作业调度与进程调度。作业调度采用短作业优先的方式，进程调度采用优先级方式或时间片轮转方式。

1. 实验目的:

   现代操作系统以进程并发、资源共享和随机访问为三个显著的特征。因而，常常有竞争处理机使用权的问题。为了使系统中各进程能有条不紊地工作，必须选择某些调度策略经过几级调度选择一个实体来使用处理机，并且，还要千方百计地提高处理机的使用效率。

   要求学生设计一个算法来仿真单处理机下作业的调度和进程的调度。

1. 实验题目:

   第一部分:调度计划生成

作业名

要求运行时间

优先级

到达时间

链接指针

作业调度表

   提示:

   (1)仿真系统到达的作业（至少5个）,其中：

      作业名      ----作业标识

      要求运行时间----即估计的作业运行时间

      优先级      ----为之创建进程的基本优先级

      到达时间    ----作业提交的时刻，可用相对时间片时间表示

          /*以上三项可随机产生(+1)或用户指定*/

      链接指针    ----指向作业调度表中的下一个作业

   (2)创建作业后应形成按主关键字为到达时间, 次关键字为要求运行时间的作业调度表．

  (3)应有显示或打印语句，能显示或打印每经过一个系统时间片后，调度表中剩余的作业．

第二部分:作业调度

作业名

要求运行时间

优先级

链接指针

                                                                  JCB

   提示:

   (1)按照系统的时间片推进，判断作业是否进入系统，将作业调度表中的作业置于作业后备队列.

      作业名      ----作业标识

      要求运行时间----即估计的作业运行时间

      优先级      ----为之创建进程的基本优先级

      链接指针    ----指向比本作业晚到来或同时到来而运行时间较短的作业

   (2)根据系统的道数要求，判断作业后备队列中的作业是否

创建作业后应形成按主关键字为到达时间, 次关键字为要求运行时间的作业后备队列．

   (3)设置系统计时域,记录运行过的时间片个数，当它的值与作业后备队列队首的一个或多个作业的到达时间一致时,将它(们)投入就绪队列．

假设系统有五个作业,每一个作业投入内存后，操作系统仅为其建立一个进程

   (4)应有显示或打印语句，能显示或打印每经过一个系统时间后，就绪队列及作业后备队列的状态．

  

第三部分:进程调度

   (一)优先级调度:

进程名

链接指针

要求运行时间

优先级

进程状态

                                                             PCB

   提示:

      (1)优先级     ----作业投入就绪队列，为其创建进程时将作业的基本优先级写入，调度时总是选择优先级最高的进程运行

         进程名      ----为作业创建进程时起的名称

链接指针    ----指向就绪队列的下一个进程，就绪队列以优先级为基础排序

要求运行时间----进程运行的相对时间片时间，由为之创建进程的作业处得到

进程状态    ----为简单起见，假定进程仅有就绪和完成状态．进程创建时处于就绪态’R’，运行结束后，置为完成状态’C’，并从就绪队列中删除．

      (2)为调度方便,设置一个指针指向就绪队列的第一个进程.

   (3)处理机调度时,选择队首进程运行……将队首进程摘除后,运行一个时间片,即执行优先级减一、时间片减一的工作. 若此时要求运行时间为0:此进程运行完毕,状态置为’C’;若不为0,则比较其优先级与队首进程的优先级:当大于等于队首进程的优先级时,继续执行一个时间片,直至小于队首进程的优先级为止,将其插入到就绪队列的合适位置上,再调度队首进程投入运行.

   (4)所设计的程序应有显示或打印语句,显示或打印选中进程的进程名及运行一次后进程就绪队列及后备作业队列的状态.

(二)时间片轮转法:(+2)

进程名

链接指针

要求运行时间

进程状态

                       PCB

   提示:

   (1)链接指针----指向下一个到来进程的PCB首地址,最后一个进程指出第一个进程的PCB首地址.

         其它如上题

   (2)设置一个队首指针指向就绪循环队列的队首进程.若有新的进程到来,则将其插入到就绪循环队列的尾端,等待下次调度.

   (3)执行处理机调度时,总是选择队首进程运行.仅执行要求运行时间减一的工作.

   (4)进程运行一次后,判断运行时间是否为0:若为0,则置状态为’C’,并退出循环就绪队列;若不为0,将其置于循环队列的尾端,等待下一轮的运行.

   (5)若就绪队列不空,反复执行(3)、(4)步骤,直至所有进程都运行完为止.

   (6)所设计的调度程序中,应包含显示或打印语句,以便显示或打印每次选中的进程名及运行一次后进程就绪队列和作业后备队列的变化情况.

1. 实验要求:

1. 给出所选实验题目.
2. 编程语言不限，使用静态指针(+1)。
3. 根据自己对于处理机调度的理解，设计独具个人特色的调度程序。
4. 给出程序中使用的数据结构及符号说明.
5. 给出程序的流程图.
6. 显示程序运行的初始状态和运行结果.
7. 收获体会及改进意见.

 

 #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <stack>
#include <ctime>
#define ERROR -1
#define JCBNUM 3 // 内存中最大容纳的进程
#define TIMELIMIT 10    //时间限制
const int Maxsize = 100 ;
using namespace std ;
typedef struct node {
	char name[20] ;
	int Arrivetime ;
	int Prioity ;
	int worktime ;
	int next ; // 下一个作业
}Job[Maxsize];
typedef struct Pcb{
	char name[20] ;
	int Prioity ; // 优先级
	int worktime ; // 要求运行时间
	char statue ; // 运行状态
	int next ; // 下一个进程号
}PCB[Maxsize];
void InitJobtable(Job job){
	for(int i = 0 ; i<Maxsize-2 ; i++ ) {
		job[i].next = i + 1 ;
	}
	job[Maxsize-2].next = 0 ;// 备用链的最后一个节点
	job[Maxsize-1].next = 0 ;// 指向第一个有效区
}
void InitProgressQueue(PCB pcb){ // 初始化进程队列
	for(int i = 0 ; i<Maxsize-2 ; i++ ) {
		pcb[i].next = i+1 ;
	}
	pcb[Maxsize-2].next = 0 ;
	pcb[Maxsize-1].next = 0 ;
}


int MallocProgress(PCB pcb){
	int i = pcb[0].next ;
	if(i){
		pcb[0].next = pcb[i].next ;
	}
	return i ;
}
int Malloc(Job job){
	int i = job[0].next ;
	if(i){
		job[0].next = job[i].next ;
	}
	return i ;
}
int ProgressQueueLength(PCB pcb){
	int i = Maxsize - 1 ;
	int len = 0 ;
	while(i){
		len++ ;
		i = pcb[i].next ;
	}
	return len ;
}
int JobTableLength(Job job){
	int i = job[Maxsize -1].next;
	int len = 0 ;
	while(i){
		len++ ;
		i = job[i].next ;
	}
	return len ;
}
void FreeProgressQueue(PCB pcb , int k){
	pcb[k].next = pcb[0].next ;
	pcb[0].next = k ;
}
void Free(Job job , int k){
	job[k].next = job[0].next ;
	job[0].next = k ;
}
bool ProgressDelete(PCB pcb ,int i ,Pcb &key){
	if(i <1 || i> ProgressQueueLength(pcb)) {
		return false ;
	}
	int k = Maxsize - 1 ;
	for(int l = 1 ;l<=i-1 ;l++){
		k = pcb[k].next ;
	}
	int j = pcb[k].next ;
	key = pcb[j];
	pcb[k].next = pcb[j].next ;
	FreeProgressQueue(pcb,j) ;
	return true;
}
bool JobDelete(Job job , int i , node &key){ // 从作业调度表中将指定的作业删除
	if(i <1 || i> JobTableLength(job)) {
		return false ;
	}
	int k = Maxsize - 1 ;
	for(int l = 1 ;l<=i-1 ;l++){
		k = job[k].next ;
	}

	int j = job[k].next ; //

	key = job[j];
	job[k].next = job[j].next ;
	Free(job,j) ;
	return true  ;
}
void PrintPCBTable(PCB pcb){
	int k = Maxsize - 1 ;
	printf("进程名\t进程优先级\t运行时间\t状态\n");
	while(pcb[k].next){
		k = pcb[k].next ;
		printf("%s\t%8d\t%8d\t%c\n",pcb[k].name,pcb[k].Prioity,pcb[k].worktime,pcb[k].statue);
	}
	cout<<endl ;
}
void PrintJcbTable(Job job){
	int k = Maxsize - 1 ;
	printf("作业名\t作业到达时间\t作业优先级\t运行时间\n");
	while(job[k].next){
		k = job[k].next ;
		printf("%s\t\t%10d\t\t%8d\t%8d\n",job[k].name,job[k].Arrivetime,job[k].Prioity,job[k].worktime);
	}
	cout<<endl ;
}
void getJobName(int i , char *name){ // 获取作业名字
	stack<char> st ;
	strcpy(name,"Job") ;
	int len = strlen(name) ;
	int t = i ;
	while(t){
		st.push('0'+t%10) ;
		t/=10 ;
	}
	while(!st.empty()){
		char now = st.top() ;
		name[len++] = now ;
		st.pop()  ;
	}

	name[len] = '\0' ;
}

bool CreateJob(Job job ,char *name,int i, int n ){
	node randJob ;
	if(i == n ){ // 哨兵节点
		strcpy(randJob.name,  "--") ;
		randJob.Arrivetime = 0 ;
		randJob.worktime = 0;
		randJob.Prioity = 0 ;
	}
	else{
		strcpy(randJob.name,name) ;
		randJob.Arrivetime = rand()%(TIMELIMIT -1 ) +1 ;
		randJob.worktime = rand()%10+1;
		randJob.Prioity = rand()%20 + 5 ;
	}

	if(i<1 || i >JobTableLength(job)+1){
		return false ;
	}
	int j = Malloc(job) ;
	int k = Maxsize - 1 ;
	
	if(j){
		//j-1  ->i-1
		for(int l = 1 ; l<=i-1 ; l++ ) {
			k = job[k].next ;
		}
		strcpy(job[j].name,randJob.name) ;
		job[j].Arrivetime = randJob.Arrivetime ;
		job[j].Prioity = randJob.Prioity ;
		job[j].worktime = randJob.worktime ;
		job[j].next = job[k].next ;
		job[k].next = j ;
	}
	
	return true ;
}
void SwapData(node *job1 , node *job2){
	node t ;
	t.Arrivetime = job1->Arrivetime ;
	t.Prioity = job1->Prioity ;
	t.worktime = job1->worktime ;
	strcpy(t.name,job1->name) ;

	job1->Arrivetime = job2->Arrivetime ;
	job1->Prioity = job2->Prioity  ;
	job1->worktime = job2->worktime ;
	strcpy(job1->name,job2->name) ;

	job2->Arrivetime = t.Arrivetime ;
	job2->Prioity = t.Prioity ;
	job2->worktime = t.worktime ;
	strcpy(job2->name,t.name) ;
	return  ;
}
void SwapDataPCB(Pcb *pcb1 , Pcb *pcb2){
	Pcb t ;

	t.Prioity = pcb1->Prioity ;
	t.worktime = pcb1->worktime ;
	strcpy(t.name,pcb1->name) ;
	pcb1->Prioity = pcb2->Prioity  ;
	pcb1->worktime = pcb2->worktime ;
	strcpy(pcb1->name,pcb2->name) ;
	pcb2->Prioity = t.Prioity ;
	pcb2->worktime = t.worktime ;
	strcpy(pcb2->name,t.name) ;
	return  ;
}
void Sort(Job job){// 按主建为到达时间,次关键为运行时间
	int head = Maxsize - 1 ;
	int p , minn , q ;
	node t ;
	for(int p = job[head].next ; job[p].next!=0 ;p = job[p].next){
		for(minn = p ,q = job[p].next ; q!=0 ;q = job[q].next){
			if(strcmp(job[q].name,"--") == 0 ) continue ;
			if(job[q].Arrivetime < job[minn].Arrivetime){
				minn = q ; // 记录最小元素的位置
			}
			else if(job[q].Arrivetime == job[minn].Arrivetime &&job[q].worktime <job[minn].worktime ){
				minn = q ;
			}
		}
		if(minn!=p){ // 将最小元素交换到链的最前面

			SwapData(&job[p],&job[minn]) ;
		}
	}
}
void SortPCB(PCB pcb){// 按主建为到达时间,次关键为运行时间
	int head = Maxsize - 1 ;
	int p , maxx , q ;
	node t ;
	for(int p = pcb[head].next ; pcb[p].next!=0 ;p = pcb[p].next){
		for(maxx = p ,q = pcb[p].next ; q!=0 ;q = pcb[q].next){
			if(pcb[q].Prioity > pcb[maxx].Prioity){
				maxx = q ; //按优先级
			}
			
		}
		if(maxx!=p){ // 将最小元素交换到链的最前面

			SwapDataPCB(&pcb[p],&pcb[maxx]) ;
		}
	}
}
bool AddQuquqback(Job BackQueue , int i , node job){
	// 将 job 加入到BackQueue :
	int j = Malloc(BackQueue) ;
	int k = Maxsize - 1 ;
	if(i<1 || i >JobTableLength(BackQueue)+1){
		return false ;
	}
	if(j){
		for(int l = 1 ; l<=i-1 ; l++ ) {
			k = BackQueue[k].next ;
		}
		strcpy(BackQueue[j].name,job.name) ;
		BackQueue[j].Arrivetime = job.Arrivetime ;
		BackQueue[j].Prioity = job.Prioity ;
		BackQueue[j].worktime = job.worktime ;
		BackQueue[j].next = BackQueue[k].next ;
		BackQueue[k].next = j ;
	}
	return true ;
}
bool AddPCBQueue(PCB ReadQueue ,int i , Pcb pcb ,int state = 0 ) {
	// 将进程 pcb 加入到 就绪队列
	int j = MallocProgress(ReadQueue) ;
	int k = Maxsize - 1 ;
	if(i<1 || i >ProgressQueueLength(ReadQueue)+1){
		return false ;
	}
	
	if(j){
		for(int l = 1 ; l<=i-1 ; l++ ) {
			k = ReadQueue[k].next ;
		}
		strcpy(ReadQueue[j].name,pcb.name) ;
		ReadQueue[j].Prioity = pcb.Prioity ;
		ReadQueue[j].worktime = pcb.worktime ;
		if(state == 1 ) {
			ReadQueue[j].statue = 'F' ;
		}
		else
		ReadQueue[j].statue = 'R' ;
		ReadQueue[j].next = ReadQueue[k].next ;
		ReadQueue[k].next = j ;
	}
	return true ;
	
}
void getProcessname(char *oldname , char *name ){
	int lenname = strlen(name) ;
	oldname[0] = 'P' ;
	oldname[1] = 'r' ;
	oldname[2] = 'o' ;
	for(int i = 3 ; i<lenname ; i ++) {
		oldname[i] = name[i] ;
	}
	oldname[lenname] = '\0' ;
	return ;
}
void InitLinkData(Job job){
	memset(job,0,sizeof(job)) ;
}
bool Work(Pcb &now){ // 执行优先级减一, 时间片减一
	cout<<"运行 : " <<now.name <<endl ;
	now.worktime -- ;
	now.Prioity -- ;
	return true ;
}
bool CreatProcess(PCB ProcessQueueready , int i , Job JobQueueback){
	// 将后备队列的队首投入就绪队列
	int k = Maxsize -1 ;
	int backfirst = JobQueueback[k].next ;
	// 排一下序 (优先级) ?
	Pcb newbase  ;
	newbase.Prioity = JobQueueback[backfirst].Prioity ;// 后备队列的收元素
	getProcessname(newbase.name ,JobQueueback[backfirst].name);
	newbase.statue = 'R' ;
	newbase.worktime =JobQueueback[backfirst].worktime ;
	if(i<1 || i >ProgressQueueLength(ProcessQueueready)+1){
		return false ;
	}
	int j = MallocProgress(ProcessQueueready) ;
	k = Maxsize - 1 ;
	if(j){
		for(int l = 1 ; l<=i-1 ; l++ ) {
			k = ProcessQueueready[k].next ;
		}
		strcpy(ProcessQueueready[j].name,newbase.name) ;
		ProcessQueueready[j].Prioity = newbase.Prioity ;
		ProcessQueueready[j].statue = newbase.statue ;
		ProcessQueueready[j].worktime = newbase.worktime ;
		ProcessQueueready[j].next = ProcessQueueready[k].next ;
		ProcessQueueready[k].next = j ;
		
	}
	return true ;
}
// 	SWAP(a,ProcessQueueRun,b,ProcessQueueready) ;
void SWAP( PCB P1 ,PCB P2) {
	// 将 P1 中的 a 进程 放到 P2 中
	// 将 P2 中的 b 进程 放到 P1 中
	Pcb temp1 , temp2 ;

	ProgressDelete(P1,1,temp1) ;
	AddPCBQueue(P2,1,temp1) ;
	SortPCB(P2) ; // 按照优先级排一下序
	ProgressDelete(P2,1,temp2) ;
	AddPCBQueue(P1,1,temp2) ;
	return ;
}
void Print(PCB pcb){
	int k = Maxsize - 1 ;
	printf("进程名\t运行时间\t状态\n");
	while(pcb[k].next){
		k = pcb[k].next ;
		printf("%s\t%8d\t%c\n",pcb[k].name,pcb[k].worktime,pcb[k].statue);
	}
	
}
int main(){
	srand((unsigned)time(0));    //设置种子
	Job jobtable ; // 作业调度表
	PCB ProcessQueueRun ; // 运行队列
	PCB ProcessQueuedone ;// 已完成的进程队列
	Job JobQueueback ; // 后备队列
	PCB ProcessQueueready ; // 就绪队列
	PCB *Queuehead ; // 队首指针
	int n  ; // 提交作业数量
	int tablenum = 0  ; // 作业调度表中作业数量
	int Queuebacknum = 0 ; // 后备队列的数量
	int Queuereadynum =  0 ; // 就绪队列的数量
	int Runnum = 0 ;
	Pcb *Point_to_now_runPcb ; // 指向运行队列的队首指针 ;
	printf("请输入生成作业数量 :  ") ;
	cin >> n ;
	n+= 1;
	InitLinkData(jobtable) ;
	InitJobtable(jobtable) ; // 初始化作业调度表
	InitJobtable(JobQueueback) ;
	InitProgressQueue(ProcessQueueRun) ;
	InitProgressQueue(ProcessQueuedone) ;
	InitProgressQueue(ProcessQueueready) ;
	for(int i = 1 ; i<=n ; i++ ) {
		char name[20] ;
		getJobName(i,name);
		if(!CreateJob(jobtable,name,i , n )){
			cout<<"Error 1!"<<endl ;
			exit(ERROR) ;
		}
		else{
			tablenum++ ;
		}
	}
	tablenum-- ;// 去掉 next 为 0 节点, 作为哨兵节点
	int indexlastjob = n ;
	Sort(jobtable) ;
	printf("作业调度表");
	PrintJcbTable(jobtable);
	int curtime = 0 ; // 系统计时, 运行过的时间片个数

	cout<<"# 时间片开始轮转"<<endl ;
	while(Queuereadynum!=0 || Queuebacknum!=0 || tablenum!=0 || Runnum !=0 ){
		curtime++ ;
		cout<<"=========================================================="<<endl ;
 		cout<<"当前系统时间 :  "<<curtime<<endl;
		 // 下面检查作业调度表,如果有作业到达,就放入到后备队列
		int p = jobtable[Maxsize - 1].next; // 后继
		bool isArrive = false ;
		int q = Maxsize - 1   ; // 前驱

		while(jobtable[p].next ){

			if(jobtable[p].Arrivetime == curtime){

				isArrive = true ;
				printf("将作业 %s 加入到后备队列\n",jobtable[p].name) ;
				// 加入到后备队列 ;
				AddQuquqback(JobQueueback,Queuebacknum+1,jobtable[p]) ;			//cout<<"test : "<<test<<endl;
				node nowdeletejobinfo  ; //当前删除的作业信息
				JobDelete(jobtable,1,nowdeletejobinfo) ; // 从作业调度表中删除
			
				 // 返回现场
				Queuebacknum++; // 后备队列加一
				tablenum-- ;//调度表减一
		
				p = q ;
			}
			q = p ;
			p = jobtable[p].next ;
			
		}
		
		if(!isArrive){
			cout<<"当前没有作业到达"<<endl ;
		}
		if(Queuereadynum == n){// 如果就绪队列满了
			// pass
		}
		else{
			if(Queuebacknum!=0 ){ // 如果后备队列非空, 将作业放入就绪队列
				CreatProcess(ProcessQueueready,Queuereadynum+1,JobQueueback) ; // 创建进程
				// 将后备队列投入到就绪队列
				// 后备队列按照 时间进入就绪队列 ?
				printf(" 将 %s 投入到就绪队列 \n",JobQueueback[JobQueueback[Maxsize-1].next].name)  ;
				node nowdeletejob ;
				JobDelete(JobQueueback,1,nowdeletejob) ; // 删除后备队列的队首元素  ;

				Queuereadynum++ ;
				Queuebacknum-- ;

			}
		}
		SortPCB(ProcessQueueready) ;
		int k = ProcessQueueready[Maxsize -1].next;
		// 就绪队列的首节点
		if(Runnum !=0 && Queuereadynum == 0 ) {
			Pcb temp ;
			cout<<"RUN 1: "<<endl;
			Point_to_now_runPcb = &ProcessQueueRun[ProcessQueueRun[Maxsize-1].next] ;
			Work(ProcessQueueRun[ProcessQueueRun[Maxsize-1].next]) ;
			if(Point_to_now_runPcb->worktime == 0 ) {
				Point_to_now_runPcb->statue = 'F' ;
				// 加入到完成队列中
					// 进程完成, 从运行队列中删除 ;
				ProgressDelete(ProcessQueueRun,1,temp);
				Runnum -- ;

				AddPCBQueue(ProcessQueuedone,1,temp,1) ;
			}
		}
		if(Queuereadynum!=0){ // 如果就绪队列不为空
			// 从就绪队列中去掉
			if(Runnum == 0 ){
				Pcb temp  ;
				Pcb temp2 ;

				ProgressDelete(ProcessQueueready,1,temp) ;
				AddPCBQueue(ProcessQueueRun, 1,temp) ; // 将就绪队列中优先级最高的送入运行队列 ;
				Runnum++ ;
				Queuereadynum-- ; // 就绪队列减一
				cout<<"RUN 2: "<<endl;
				Point_to_now_runPcb = &ProcessQueueRun[ProcessQueueRun[Maxsize-1].next] ;
				// 指向运行队列的队首
				Work(ProcessQueueRun[ProcessQueueRun[Maxsize-1].next]);
				
				cout<<"运行队列"<<endl;
				PrintPCBTable(ProcessQueueRun) ;
				if(Point_to_now_runPcb->worktime == 0 ) {
					Point_to_now_runPcb->statue = 'F' ;
					// 加入到完成队列中
						// 进程完成, 从运行队列中删除 ;
					ProgressDelete(ProcessQueueRun,1,temp);
					Runnum -- ;
				
					AddPCBQueue(ProcessQueuedone,1,temp,1) ;
					cout<<"完成队列"<<endl ;
					PrintPCBTable(ProcessQueuedone) ;
				}

			}
			else{
				int nowfont = ProcessQueueready[Maxsize -1].next; // 当前队首下标

				if(ProcessQueueRun[ProcessQueueRun[Maxsize-1].next].Prioity < ProcessQueueready[nowfont].Prioity){
					// 如果当前处理机处理的进程 的 优先级 低于 就绪队列队首的优先级
					// 让处理机放弃该进程 ,并给当前就绪队列队首进程使用处理机,
					// 该进程重新放入到就绪队列,等待下一次调度  ;
					Pcb a = ProcessQueueRun[ProcessQueueRun[Maxsize-1].next] ; //正在运行的进程
					Pcb b = ProcessQueueready[nowfont] ; // 就绪进程的队首 ;
					cout<<b.name <<" 强占处理机"<<endl;
					cout<<a.name <<"被剥夺处理机"<<endl ;
					SWAP(ProcessQueueRun,ProcessQueueready) ;
					// 将 a 放入 就绪队列 等待下一次调度
					// 将 b 放入 运行队列 ,继续运行 ;
					cout<<"运行"<<endl;
					PrintPCBTable(ProcessQueueRun) ;
					cout<<"就绪"<<endl ;
					PrintPCBTable(ProcessQueueready) ;
				}
				else{
					// run 运行队列中的进程
					Pcb temp ;
					PrintPCBTable(ProcessQueueRun) ;
					Point_to_now_runPcb = &ProcessQueueRun[ProcessQueueRun[Maxsize-1].next] ;
					cout<<"RUN 3: "<<endl;
					Work(*Point_to_now_runPcb) ;
					cout<<"运行"<<endl;
					
					if(Point_to_now_runPcb->worktime == 0 ) {
						Point_to_now_runPcb->statue = 'F' ;
						// 加入到完成队列中
							// 进程完成, 从运行队列中删除 ;
						ProgressDelete(ProcessQueueRun,1,temp);
						Runnum -- ;

						AddPCBQueue(ProcessQueuedone,1,temp,1) ;
						cout<<"完成队列"<<endl ;
						PrintPCBTable(ProcessQueuedone) ;
					}
					PrintPCBTable(ProcessQueueRun) ;
				}
				
				
			}
			
			
		}

//		cout<<"-- 运行队列 -- 就绪队列 -- 已完成队列 --"<<endl;
		
		cout<<"作业调度表 : "<<endl ;
		PrintJcbTable(jobtable) ;
		cout<<"后备队列"<<endl;
		PrintJcbTable(JobQueueback) ;
		cout<<"就绪队列"<<endl;
		Print(ProcessQueueready) ;
		cout<<"运行队列"<<endl ;
		Print(ProcessQueueRun) ;
		cout<<"完成队列"<<endl;
		Print(ProcessQueuedone) ;
		
		cout<<"Number of Job schedule : "<<tablenum<<endl;
		cout<<"Number of Backup queue : " <<Queuebacknum<<endl;
		cout<<"Number of Ready queue : "<<Queuereadynum<<endl;
		cout<<"Number of Running queue : "<<Runnum<<endl;
		cout<<"============================================================"<<endl<<endl ;
		getchar();
	
	}


	return 0 ;
}

实验截图 :