精华内容
下载资源
问答
  • 操作系统 时间片轮转法, 算法 , 源代码,c语言的
  • 时间片轮转法进行CPU调度 包含源代码 课程设计报告
  • 时间片轮转法

    2014-05-03 22:11:01
    1. 进程调度算法包括:时间片轮转法,短作业优先算法,动态优先级算法。 2. 可选择进程数量 3. 本程序包括三种算法,用C语言实现,执行时在主界面选择算法(可用函数实现),进入子页面后输入进程数,(运行时间,...
  • 这个是关于操作系统进程管理实验的时间片轮转法的源程序
  • 进程调度 时间片轮转调度算代码(C语言)
  • 一个小程序,自己写的进程调度,采用时间片轮转法 调度进程,操作系统的实验作业。其中包括 源代码,可执行文件和 实验报告还有演示PPT
  • 操作系统上机实习:利用C++实现时间片轮转法 概念解析:        在时间片轮转法中,系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择就绪队列中的第...

    操作系统上机实习:利用C++实现时间片轮转法

    概念解析:

           在时间片轮转法中,系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择就绪队列中的第一个进程执行,并规定执行一定时间,即时间片。当该进程用完该时间片但仍未运行完成时,系统将其送至就绪队列末尾;若在时间片内运行完成,则重置时间片,执行就绪队列中的第一个进程。如此循环,直至完成为止。

    程序流图:

    在这里插入图片描述

    代码实现:
    #include <iostream>
    #include <string>
    #define MAX 20    //最大进程数
    
    using namespace std;
    //
    //实习1题目名称:利用时间片轮转法实现处理器调度
    //
    
    //进程数据结构
    struct PCB {
    	string name;                     //进程名
    	int arrive;                          //进程到达时间
    	int need;                           //进程请求时间
    	int count = 0;                   //进程已运行时间
    	bool status = true;           //进程状态,true:就绪   false:结束   (默认就绪)
    	bool isOK = false;            //显示进程是否已经添加到循环队列, true代表已添加(默认为false)
    };
    
    PCB p[MAX];                        //定义进程数组
    PCB queue[MAX];               //循环队列,存在覆盖的可能
    int front = -1, rear = -1;     //队头、队尾指针
    
    int main() {
    
    	while (1) {
    		int num, time, all = 0;                 //进程数, 时间片大小, 所有进程所需总时间
    		int latest = 0;                             //进程进入队列最晚的时间,用来将进程放入队列
    		string isGoOn;                           //是否要继续输入
    		string detail;                              //true代表输出详细信息,false表示不输出详细信息
    
    		cout << "请输入进程个数:";
    		cin >> num;
    		if (num > 20) {
    			cout << "进程数超过最大值!" << endl;
    			break;
    			system("pause");
    		}
    		if (num <= 0) {
    			cout << "输入进程数应大于0!" << endl;
    			system("pause");
    		}
    		for (int i = 0; i < num; i++) {    //进行重置,用于重复输入
    			p[i].status = true;
    			p[i].isOK = false;
    			p[i].count = 0;
    		}
    
    		cout << "请输入时间片大小:";
    		cin >> time;
    		if (time <= 0) {
    			cout << "时间片应大于0" << endl;
    			system("pause");
    		}
    		cout << "是否输出详细调度过程(y/n):";
    		cin >> detail;
    
    		cout << "请依次输入进程名、进程到达时间和进程要求运行时间:";
    		for (int i = 0; i < num; i++) {
    			cin >> p[i].name >> p[i].arrive >> p[i].need;
    			all += p[i].need;   //总时间
    			if (latest < p[i].arrive)
    				latest = p[i].arrive;
    		}
    
    		if (detail == "y")
    			cout << "进程名" << "\t" << "已运行" << "\t" << "状态" << "\t" << "当前时刻" << endl;
    		else
    			cout << "进程名" << "\t" << "完成时刻" << endl;
    
    		//根据进程到达时间进行排序,有利于时间片未用完的情况
    		for (int i = 0; i < num; i++)
    			for (int j = i + 1; j < num; j++) {
    				if (p[i].arrive > p[j].arrive) {
    					PCB temp = p[i];
    					p[i] = p[j];
    					p[j] = temp;
    				}
    			}
    
    		int t = 0;
    		while (t < all + latest) {   //当t小于总时间时
    
    			if (t <= latest) {    //当小于latest时,可能需要向队列中添加进程
    				for (int i = 0; i < num; i++) {
    					if (p[i].isOK == false && t >= p[i].arrive) {   //向循环队列中添加进程
    						p[i].isOK = true;         //防止重复添加
    						rear = (rear + 1) % MAX;
    						queue[rear] = p[i];    //进队列
    					}
    				}
    			}
    
    			if ((rear - front) != 0) {
    				front = (front + 1) % MAX;   //出队列
    				if ((queue[front].need - queue[front].count) <= time) {
    					if (detail != "y")             //输出简略信息
    						cout << queue[front].name << "\t" << t + queue[front].need - queue[front].count << endl;
    					queue[front].status = false;   //运行结束,状态设为false
    
    					t += (queue[front].need - queue[front].count);   //当前时间自增
    					queue[front].count = queue[front].need;
    					if (detail == "y")                                                   //输出具体信息
    						cout << queue[front].name << "\t" << queue[front].count << "\t" << queue[front].status << "\t" << t << endl;
    					continue;
    				}
    				else {
    					queue[front].count += time;    // 已运行时间自增
    					t += time;    //t以time为单位自增
    					if (t <= latest + time) {    //当小于latest时,可能需要向队列中添加进程
    						for (int i = 0; i < num; i++) {
    							if (p[i].isOK == false && t >= p[i].arrive) {   //向循环队列中添加进程
    								p[i].isOK = true;         //防止重复添加
    								rear = (rear + 1) % MAX;
    								queue[rear] = p[i];    //进队列
    							}
    						}
    					}
    
    					rear = (rear + 1) % MAX;
    					queue[rear] = queue[front];    //进程未完成重新进入队列
    					if (detail == "y")
    						cout << queue[front].name << "\t" << queue[front].count << "\t" << queue[front].status << "\t" << t << endl;
    					continue;
    				}
    			}
    			t++;  //当到达时间不连续时
    		}
    		cout << "你想执行新进程吗(y/n)?";
    		cin >> isGoOn;
    		if (isGoOn == "y") {
    			continue;
    		}
    
    		if (isGoOn == "n")
    			system("pause");
    		else {
    			cout << "请输入:y/s" << endl;
    			system("pause");
    		}
    	}
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 设计一个按时间片轮转法实现处理器调度的程序
  • 时间片轮转代码

    千次阅读 2018-05-23 22:52:52
    #include&lt;stdio.h&gt;#define MAX 10struct task_struct{ char name[10]; /*进程名称*/ float arrivetime; /*到达时间*/ float starttime; /*开始运行时间*/ float runtime; /*运行时间...
    #include<stdio.h>
    
    #define MAX 10
    struct task_struct
    {
        char name[10];           /*进程名称*/


        float arrivetime;         /*到达时间*/
        float starttime;     /*开始运行时间*/
        float runtime;          /*运行时间*/
        float finishtime;      /*运行结束时间*/


        int runflag;          /*调度标志*/
        int startflag;     //是否为第一次开始调度
    } tasks[MAX];
    int counter; /*实际进程个数*/
    int pinput();
    int timecounter=0;
    int poutput(); /*调度结果输出*/
    int time();
    int charge();//判断是否所有的进程都被执行过


    int time()
    {
        float temp=0;//用来记录时间片已用长度
        int i;
        int j=0;
        int k=0;


        struct task_struct  copy_task[MAX];//备份
        for(i=0; i<counter; i++)
        {
            copy_task[j++]=tasks[i];//对进程的初始化信息备份
        }


        temp=tasks[0].arrivetime;//temp=第一个进程的到达时间
        while(charge())//while条件,charge为0跳出(说明进程都已经全部执行完毕),为1进入(进程还未执行完毕,继续执行)
        {
            for(i=0; i<counter; i++)
            {
                if(tasks[i].arrivetime>temp)//如果第i个的到达时间大于第一个的到达时间,则将第i个的到达时间与temp交换,更新temp的记录,但是第一次运行的时候不走这一步
                {
                    temp=tasks[i].arrivetime;
                }
                if(tasks[i].runflag==0)//第i个进程还未结束
                {
                    if(tasks[i].startflag==0)  //该条件成立则说明,该进程是第一次执行,记录开始执行时间
                    {
                        tasks[i].starttime=temp;//第一个进程的到达时间为temp
                        tasks[i].startflag=1;//运行完上一步后记录该进程已经不是第一次运行了
                    }
                    if(tasks[i].runtime/timecounter>1)//,运行时间除以时间片长度,说明至少有两倍的时间片未执行
                    {
                        tasks[i].runtime=tasks[i].runtime-timecounter;//剩余运行时间就等于原来运行时间减去一个时间片长度
                        temp=temp+timecounter;//temp继续记录已用的时间片长度
                    }
                    else if(tasks[i].runtime-timecounter==0)//即运行时间除以时间片长度为1,该进程剩下的刚好是一个时间片长度,说明该进程只需在运行一一步就可以运行完毕
                    {
                        temp=temp+timecounter;//temp加上最后一个时间片长度就为该进程的结束时间
                        tasks[i].finishtime=temp;
                        tasks[i].runflag=1;//标记该进程已经执行完毕
                        tasks[i].runtime=copy_task[i].runtime;//为了计算周转时间,运行时间从备份里面还原到最开始的运行时间
                    }
                    else//仅剩下不足一倍的时间片,则剩余运行时间除以时间片长度<1
                    {
                        temp=temp+tasks[i].runtime;//剩余运行时间不够一个时间片长度,则结束时间等于temp加上该进程的运行时间
                        tasks[i].finishtime=temp;
                        tasks[i].runflag=1;//标记该进程已经运行完毕
                        tasks[i].runtime=copy_task[i].runtime;
                    }
                }
            }
        }
    return 0;
    }


    int charge()//判断是否全部进程都执行完毕
    {
        int k;
        int superflag=0;//判断是否全部的进程都执行完毕
        for(k=0; k<counter; k++)
        {
            if(tasks[k].runflag==0)//只要
            {
                superflag=1;
                return superflag;
                break;
            }
            else
            {
                superflag=0;
            }
        }
        return superflag;
    }


    int pinput() /*进程参数输入*/
    {
        int i;
        printf("请输入进程个数:\n");
        scanf("%d",&counter);
        printf("请输入时间片长度:\n");
        scanf("%d",&timecounter);
        for(i=0; i<counter; i++)
        {
            printf("******************************************\n");
    printf("请输入进程名称、到达时间、运行时间:(中间用空格隔开)\n");
    scanf("%s%f%f",tasks[i].name,&tasks[i].arrivetime,&tasks[i].runtime);


            tasks[i].starttime=0;
            tasks[i].finishtime=0;
            tasks[i].runflag=0;  //运行是否结束
            tasks[i].startflag=0;//是否首次被执行
        }
        return 0;
    }


    int poutput() /*调度结果输出*/
    {
        int i;
        float zztime=0,f1,w=0;
        printf("进程名 到达时间 运行时间 开始时间 结束时间 周转时间\n");
        for(i=0; i<counter; i++)
        {
            f1=tasks[i].finishtime-tasks[i].arrivetime;
            zztime+=f1;
            printf("%s\t%5.3f\t%5.3f\t%5.3f\t %5.3f\t%5.3f\n",tasks[i].name,tasks[i].arrivetime,tasks[i].runtime,tasks[i].starttime,tasks[i].finishtime,f1);
        }
        printf("平均周转时间=%5.2f\n",zztime/counter);
        return 0;
    }


    void main()
    {


        pinput();
        printf("时间片轮转算法。\n\n");
        time();
        poutput();
    }
    展开全文
  • #include #include <iomanip.h> #include #include #include class PCB { public: char name[10]; int pr; int round; int costtime; int needtime;
  • 模拟进程调度算法-时间片轮转算法 /* 进程调度模拟实验代码实现 我采用的是时间片轮转调度算法 */ #include<iostream> #include<cmath> #include<cstring> #include<cstdio> #include<...

    模拟进程调度算法-时间片轮转算法

    /*
    进程调度模拟实验代码实现
    我采用的是时间片轮转调度算法  
    */ 
    
    #include<iostream>
    #include<cmath>
    #include<cstring>
    #include<cstdio>
    #include<cstdlib> 
    #include<iomanip>
    #include<algorithm>
    #define N 25
    #define NN 110
    
    using namespace std;
    
    int num; // 进程的数量 
    
    //p结构体数组存放临时数据;
    //res结构体数组存放最后结果
     
    struct Node{
    	string str_name; // 名字 
    	int time_arrive; // 到达时间 
    	int time_serve; // 服务时间 
    	int	time_surplus; // 剩余服务时间 
    	int time_begin; // 开始时间 
    	int time_finish; // 完成时间 
    	int time_revolve; // 周转时间
    	double weight;  // 带权 
    	int flag_finish; // 标识位(看有无进程) 
    }p[N], res[NN];  
    
    //输入 
    void input(int u){
    	for(int i=0;i<u;i++){
    		cout << "请输入进程名, 到达时间, 服务时间" << endl;
    		cin >> p[i].str_name;
    		cin >> p[i].time_arrive;
    		cin >> p[i].time_serve;
    		// 输入的数据同时也放在res结构体数组中
    		res[i].str_name = p[i].str_name; 
    		res[i].time_arrive = p[i].time_arrive;
    		res[i].time_serve = p[i].time_serve;
    	}
    }
    
    //输出 
    void output(int u){
    	cout << endl;
    	cout << endl;
    	cout << "结果数据: " << endl;
    	cout << "        ";
    	cout << "进程名" << setw(10) 
    		 << "到达时间" << setw(10) 
    		 << "服务时间" << setw(10) 
    		 << "开始时间" << setw(10) 
    		 << "完成时间" << setw(10)
    		 << "周转时间" << setw(10)
    		 << "带权时间" << endl; 
    	
    	for(int i=0;i<u;i++){
    		cout << "        ";
    		cout << setw(3) << res[i].str_name
    			 << setw(10) << res[i].time_arrive
    			 << setw(10) << res[i].time_serve
    			 << setw(10) << res[i].time_begin
    			 << setw(10) << res[i].time_finish
    			 << setw(10) << res[i].time_revolve
    			 << setw(13) << res[i].weight << endl;
    	}
    }
    
    //按照到达时间将进程从小到大排序 
    bool cmp(Node a, Node b){
    	return a.time_arrive < b.time_arrive;
    }
    
    
    void convert_to_res(int m, int n){
    	// 开始时间(从前往后遍历) 
    	for(int i=0;i<m;i++){
    		for(int j=0;j<n;j++){
    			if(res[i].str_name == p[j].str_name){
    				res[i].time_begin = j;
    				break;
    			}
    		}
    	}
    	
    	//完成时间(从后往前)
    	for(int i=0;i<m;i++){
    		for(int j=n-1;j>=0;j--){
    			if(res[i].str_name == p[j].str_name){
    				res[i].time_finish = j + 1;
    				break;
    			}
    		}
    	}
    	
    	// 周转时间(完成 - 到那)
    	for(int i=0;i<m;i++){
    		if(i <= 1){
    			res[i].time_revolve = res[i].time_finish - res[i].time_begin;
    		}else{
    			res[i].time_revolve = (res[i].time_finish - res[i].time_begin) + (i - 1);
    		}
    	} 
    	
    	// 带权(周转/服务)
    	for(int i=0;i<m;i++){
    		res[i].weight = double(res[i].time_revolve) / double(res[i].time_serve);
    	}
    }
    
    void Main(int u){
    	
    	cout << "请输入时间片长度:" << endl;
    	int m;
    	cin >> m;
    	
    	int flag = 1;//标志队列中是否还有进程
    	int Count_finish = 0;//完成的进程数
    	
    	cout << "过程数据: " << endl; 
    	cout << "        ";
    	cout << "进程名称" << setw(15)
    		 << "开始时间" << setw(15)
    		 << "运行时间" << setw(15) 
    		 << "剩余服务时间" << setw(15)
    		 << "结束时间" << endl;
    	
    	int time;  //记录现在时间
    	int c = 0; // 计数器(记录次数) 
    	while(Count_finish < u){ // 完成的进程没有达到进程的数量 
    		flag = 0; // 表示就绪队列里没有进程
    		for(int i=c;i<u;i++){
    			sort(p, p+u, cmp); // 按照进程到达时间从小到大排序 
    			p[i].time_surplus = p[i].time_serve;
    			p[i].time_begin = p[i-1].time_finish; //上一个作业结束时间
    			
    			/*
    				判断该进程的开始时间与到达时间的关系
    				1、如果开始时间小于到达时间,那么开始时间 == 到达时间;
    				2、否则开始时间 == 上一个进程的完成时间 
    			*/ 
    			if(p[i].time_begin < p[i].time_arrive){
    				p[i].time_begin = p[i].time_arrive;
    			}else{
    				p[i].time_begin = p[i-1].time_finish;
    			}
    			
    			time = p[i].time_begin; // 当前时间为当前进程的开始时间 
    			if (p[i].flag_finish == 1){ //表示当前进程已完成 
    				continue;
    			}else{
    				if(p[i].time_surplus <= m && time >= p[i].time_arrive){
    					flag = 1;
    					time = time + p[i].time_surplus;
    					p[i].flag_finish = 1;//该进程完成
    					p[i].time_finish = time;
    					cout << "      ";
    					cout  << setw(8) << p[i].str_name
    						  << setw(13) << (p[i].time_finish - p[i].time_surplus) 
    						  << setw(15) << p[i].time_surplus 
    						  << setw(16) << 0
    						  << setw(18) << p[i].time_finish << endl;
    						
    					p[i].time_surplus = 0;  //进程完成后剩余时间为0 
    				}else if(p[i].time_surplus > m && time >= p[i].time_arrive){
    					// 如果该进程的剩余时间 > 时间片并且当前时间 > 该进程的到达时间 
    					flag = 1;
    					time += m; // 自然当前时间要加上时间片
    					p[i].time_surplus -= m; // 剩余时间要减去时间片 
    					p[i].time_finish = time; // 完成的时间就是当前的时间 
    				
    					cout << "      ";
    					cout << setw(8) << p[i].str_name
    						 << setw(13) << (time - m)
    						 << setw(15) << m
    						 << setw(16) << p[i].time_surplus
    						 << setw(18) << p[i].time_finish << endl;
    					 
    					p[u].str_name = p[i].str_name;
    					p[u].time_arrive = time;
    					p[u].time_serve = p[i].time_surplus;
    					u++;
    				}
    				if(p[i].flag_finish == 1){
    					Count_finish ++;  //一个进程完成加一
    				}
    			}
    			c++;
    		}
    		break;
    		if(flag == 0 && Count_finish < u){
    			//没执行完且没进入就绪队列
    			for(int i=0;i<u;i++){
    				if(p[i].flag_finish == 0){
    					time = p[i].time_arrive;
    					break;
    				}
    			}
    		}
    	}
    	
    //临时的数据输出 
    //	output(u);
    //	cout << endl;
    	
    //	cout << "c is : " << c << endl;
    //	cout << "u is : " << u << endl;	
    
    // 将数据存放在res结构体数组中
    	int ans = num;
    	convert_to_res(ans, u);	
    }
    
    int main () {
    	int n;
    	cout << "请输入进程的数量:";
    	cin >> n;
    	num = n; 
    	
    //	cout << n << endl;
    	input(n); // 输入 
    	Main(n); // 执行时间片轮转算法 
    	output(n); // 输出结果
    	
    	return 0;
    }
    
    
    // 样例
    /*
    输入:
    p1 0 3
    p2 2 6
    p3 4 4 
    p4 6 5 
    p5 8 2 
    时间片:1 
    */ 
    
    /*
    输出:
    过程结果:这里只写进程顺序
    		  p1p1p2p1p2p3p2p4p3p2p5p4p3p2p5p4p3p2p4p4 
    最后结果表:
     
    进程名    到达时间    服务时间     开始时间    完成   周转  带权 
      p1         0           3            0         4      4     4/3(浮点数显示)
      p2         2           6            2         18     16    16/6
      p3         4           4            5         17     13    13/4
      p4         6           5            7         20     15    15/5
      p5         8           2            10        15     8     8/2 
    
    */ 
    

    运行结果

    在这里插入图片描述

    展开全文
  • 题目一:设计一个按照时间片轮转法实现处理机调度的程序 时间片轮转法实现处理机调度的程序设计提示如下: (1)假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且参数...

    一、实验目的及要求
    题目一:设计一个按照时间片轮转法实现处理机调度的程序
    时间片轮转法实现处理机调度的程序设计提示如下:
    (1)假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且参数意义也相同。

    进程名
    链接指针
    到达时间
    估计运行时间
    进程状态

    (2)按照进程到达的先后顺序排成一个循环队列,设一个队首指针指向第一个到达进程的首址。另外再设一个当前运行进程指针,指向当前正运行的进程。
    (3)执行处理机调度时,首先选择队首的第一个进程运行。
    (4)由于本题目是模拟实验,所以对被选中的进程并不实际启动运行,而只是执行如下操作:1)估计运行时间减1;
    2)输出当前运行进程的名字。
    用这两个操作来模拟进程的一次运行。
    (5)进程运行一次后,以后的调度则将当前指针依次下移一个位置,指向下一个进程,即调整当前运行指针指向该进程的链接指针所指进程,以指示应运行进程,同时还应判断该进程的剩余运行时间是否为0,若不为0,则等待下一轮的运行,若该进程的剩余运行时间为0,则将该进程的状态置为完成状态“C”,并退出循环队列。
    (6)若就绪队列不为空,则重复上述的步骤(4)和(5)直到所有进程都运行完为止。
    (7)在所设计的调度程序中,应包含显示或打印语句,以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

    二、程序中使用的数据结构及主要符号说明
    (1)、进程结构体,结构体的变量有进程名字(PCBName)、进程到达时间(arriveTime)、进程运行时间(runTime)、进程状态(status)。并且进程信息用一个结构体数组pcb[PCBNum]来存储。

    typedef struct{//进程结构体
        char PCBName;//进程名字
        int arriveTime;//进程到达时间
        int runTime;//进程运行时间
        char status;//进程状态
    }PCB;
    pcb[PCBNum];//创建进程结构体数组
    

    (2)、就绪队列我用了链队来存储,因此创建了一个结点结构体QueueNode,一个链式队列结构体LinkQueue。结点结构体里面的变量有一个PCB结构体数据,一个指向下一个结点的指针next;链式队列结构体里面的变量有指向队列头部的指针front,指向队列尾部的指针rear,表示队列长度的整型数据Q_size。

    typedef struct QueueNode//定义一个结点   
    {
        PCB data;
        struct QueueNode *next;
    }QueueNode;
    
    typedef struct{//链式队列
        QueueNode *front;//队头指针
        QueueNode *rear;//队尾指针
        int Q_size;//队列中元素的个数
    }LinkQueue;
    

    (3)、主要符号说明:
    PCB类型的变量pcb1,用以保存执行一次后出队的进程,作为中间变量,确保第二个时间让下一个进程入队后出队元素再再次插入就绪队列队尾。

    PCB pcb1;//用于保存出队元素
    

    MAX表示无穷,用以防止程序首次运行时就将没有数据的pcb1入队造成程序错误,也用于防止程序执行完毕后该程序再次入队。

    #define MAX 99999//表示无穷
    

    整型变量n用于表示判断该时刻有无进程到达的循环体循环次数,整型变量PCBNum表示进程个数,整型变量m用于判断何时退出时间循环,即什么时候进程全部执行完毕。

        int n=0;//表示循环次数
        int PCBNum=(rand()%4)+3;//进程数初始化为3-6个
        int m=PCBNum;//用于判断何时退出时间循环
    

    三、程序流程图和带有注释的源程序
    程序流程图:
    在这里插入图片描述

    源代码:

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #define MAX 99999//表示无穷
    
    typedef struct{//进程结构体
        char PCBName;//进程名字
        int arriveTime;//进程到达时间
        int runTime;//进程运行时间
        char status;//进程状态
    }PCB;
    
    typedef struct QueueNode//定义一个结点   
    {
        PCB data;
        struct QueueNode *next;
    }QueueNode;
    
    typedef struct{//链式队列
        QueueNode *front;//队头指针
        QueueNode *rear;//队尾指针
        int Q_size;//队列中元素的个数
    }LinkQueue;
    
    void init(PCB a[],int n){//初始化进程
        char name='A';
        for(int i=0;i<n;i++){
            a[i].PCBName=name;//进程名
            a[i].arriveTime=rand()%8;//进程到达时间初始化为0-7
            a[i].runTime=(rand()%4)+2;//进程运行时间初始化为2-5
            a[i].status='R';//进程状态初始化为就绪状态"Reader"
            name++;
        }
    }
    
    void sort(PCB c[],int n){//按照进程到达时间进行排序(冒泡排序)
        PCB temp;
        for(int i=0;i<n-1;i++){
            for(int j=0;j<n-1-i;j++){
                if(c[j].arriveTime>c[j+1].arriveTime){
                    temp=c[j];
                    c[j]=c[j+1];
                    c[j+1]=temp;
                }
            }
        }
    }
    
    void show(PCB b[],int n){//输出进程信息
        printf("进程信息:\n");
        printf("进程名字\t进程到达时间\t进程运行时间\t进程状态\n");
        for(int i=0;i<n;i++){
            printf("  %c\t\t    %d\t\t   %d\t\t  %c",b[i].PCBName,b[i].arriveTime,b[i].runTime,b[i].status);
            printf("\n");
        }
        printf("************************开始执行*****************************\n");
    }
    
    void InitQueue(LinkQueue *Q){//构造一个空队列
        Q->front=Q->rear=NULL;
        Q->Q_size=0;
    }
    
    void EnQueue(LinkQueue*Q,PCB data){//入队
        QueueNode *newNode1=(QueueNode*)malloc(sizeof(QueueNode));//为入队元素分配结点空间
        newNode1->data=data;
        newNode1->next=NULL;
        if(Q->Q_size==0){//队列为空
            Q->front=newNode1;
            Q->rear=newNode1;
            Q->Q_size++;//队列元素+1
        }
        else{//队列不为空
            Q->rear->next=newNode1;
            Q->rear=newNode1;
            Q->Q_size++;//队列元素+1
        }
    }
    
    void DeQueue(LinkQueue*Q){//出队
        if(Q->Q_size==0){//队列为空
            exit(1);
        }
        else if(Q->Q_size==1){//队列只有一个元素
            Q->front=NULL;
            Q->rear=NULL;
            Q->Q_size--;//队列元素减1
        }
        else{
            QueueNode *q=(QueueNode*)malloc(sizeof(QueueNode));//申请内存
            q=Q->front;//q指向队头元素
            q->data=Q->front->data;//保存队头元素的值
            Q->front=q->next;//修改头指针
            Q->Q_size--;//队列元素-1
            free(q);//释放内存
        }
    }
    
    void DestroyQueue(LinkQueue *Q){//销毁队列
        if(Q->front!=NULL){
            Q->rear=Q->front;
            free(Q->front);
            Q->front=Q->rear;
        }
    }
    
    void remove_pcb(PCB e[],int n){//移除队列中运行时间为0的进程
        int i=0;
        int j=0;
        for(int k=0;k<n;k++){
            if(e[k].runTime!=0){
                e[i]=e[j];
                i++;
            }
            j++;
        }
    }
    
    void show_Q(LinkQueue *Q){//遍历就绪队列
        QueueNode *newNode2=(QueueNode*)malloc(sizeof(QueueNode));
        if(Q->front!=NULL){
            newNode2=Q->front;
            do{
                printf("进程名字:%c\t进程到达时间:%d\t进程剩余运行时间:%d\t进程状态:%c\n",newNode2->data.PCBName,\
                newNode2->data.arriveTime,newNode2->data.runTime,newNode2->data.status);
                newNode2=newNode2->next;
            }while(newNode2!=NULL);
        }
        else{
            printf("就绪队列中无进程!\n");
        }
    }
    
    void main(){
        srand((unsigned int)time(0));
        int n=0;//表示循环次数
        int PCBNum=(rand()%4)+3;//进程数初始化为3-6个
        int m=PCBNum;//用于判断何时退出时间循环
        PCB *pcb=(PCB*)malloc(PCBNum*sizeof(PCB));
        pcb[PCBNum];//创建进程结构体数组
        PCB pcb1;//用于保存出队元素
        pcb1.arriveTime=MAX;//将pcb1的到达时间初始化为无穷大,防止pcb1首次运行时就入队
        init(pcb,PCBNum);//初始化进程数据
        sort(pcb,PCBNum);//按照进程到达时间排序
        show(pcb,PCBNum);//输出进程信息
        LinkQueue *Q=(LinkQueue*)malloc(sizeof(LinkQueue));
        InitQueue(Q);//初始化队列
        for(int time=0;;time++){//表示时间增加
            n=m;//更新循环次数
            printf("\n时间%d:\n",time);
            for(int i=0;i<n;i++){
                if(time==pcb[i].arriveTime){//当前时间有进程到达
                    EnQueue(Q,pcb[i]);//入队
                    printf("进程%c到达\n",pcb[i].PCBName);//输出执行的进程名
                }  
            }
            if(pcb1.arriveTime!=MAX){
                EnQueue(Q,pcb1);//重新将头元素入队
            }
            printf("就绪队列中的进程状态:\n");
            show_Q(Q);//输出就绪队列进程信息
            if(Q->Q_size!=0){//就绪队列中不为空
                for(int i=0;i<PCBNum;i++){//更新pcb数组中的进程信息
                    if(pcb[i].PCBName==Q->front->data.PCBName){
                        pcb[i].runTime--;//运行时间-1
                        if(pcb[i].runTime==0){
                            pcb[i].status='C';//进程状态更新为“C"
                            m--;//进程数减1
                        }
                        break;
                    }
                }
                printf("进程%c正在执行\n",Q->front->data.PCBName);
                Q->front->data.runTime--;//正在执行的进程运行时间减1
                if(Q->front->data.runTime==0){//进程执行完毕
                    Q->front->data.status='C';//进程状态更新为“C”
                    printf("进程%c已执行完毕,退出就绪队列\n",Q->front->data.PCBName);
                    DeQueue(Q);//出队
                    pcb1.arriveTime=MAX;//更新pcb1中的值,防止再次入队
                }
                else{
                    pcb1=Q->front->data;//保存就绪队列队头元素
                    DeQueue(Q);//出队
                }
                remove_pcb(pcb,n);//移除进程队列中运行时间为0的进程
                if(m<=0){//进程全部执行完
                    printf("\n进程已经全部执行完毕!\n");
                    break;
                }
            }
            else{//无进程到达
                printf("无进程到达,无进程运行\n\n");
            }
        }
        free(pcb);
        DestroyQueue(Q);
        printf("队列已销毁!\n");
        system("pause");
    }
    

    四、执行程序名,并打印程序运行时的初值和运算结果
    第一次测试:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 时间片轮转法实现处理机调度的程序设计提示如下: (1)假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且参数意义也相同。 进程名 链接指针 到达时间 估计运行...
  • 本片博文分享操作系统课程设计–使用多线程模拟时间片轮转法调度算法 实验环境:ubuntu18.04 ,VS Code 1、题目: 设计一个按照时间片轮转法实现处理机调度的程序,时间片轮转法实现处理机调度的程序设计提示如下: ...
  • 用C++语言写的一个简单的时间片轮转算法模拟CPU调度过程,写得不好请轻拍
  • 操作系统中的模拟进程管理,有优先级算法和时间片轮转法两种算法,在原有三种状态上加入阻塞判断,阻塞后进入等待状态。
  • 有利于操作系统实训 简单易懂 功能齐全
  • 设计一个按照时间片轮转法实现处理机调度的程序 时间片轮转法实现处理机调度的程序设计提示如下: (1) 假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且参数意义也相同...
  • 1)本程序是由Dev-C++4.9.9.2编译通过,并生成.exe执行文件,不存在逻辑上的错误。...(3)进程调度算法模拟,用动态优先数及时间片轮转法 实现进程调度。采用数据结构单链表实现。 (4)最后祝各位学有所成。
  • RT-thread 时间片轮转法

    千次阅读 2018-09-22 11:05:07
    时间片轮转 主要用于分时系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时,进程调度程序总是选出就绪队列的队首进程,让它...
  • 按照时间片轮转法实现处理机调度程序设计一个按照时间片轮转法实现处理机调度的程序课程设计题目及要求程序中使用的数据结构及主要符号说明带有注释的源代码运行程序输出初值及运算结果 设计一个按照时间片轮转法...
  • 可变时间片轮转法 c语言的简易实现 基本思想: 所有就绪进程按 FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。如果运行进程用完它的时间片后还为完成,就把它送回到就绪队列的末尾,...
  • RR时间片轮转法调度C语言实现

    千次阅读 2020-05-18 18:34:11
    在FCFS的基础上,加入时间片的概念,从第一个到达的进程开始,CPU分配其一个时间片的长度,第一个进程放到其余任务后面,然后给第二个进程分配一个时间片,第二个进程放到其余任务后面,依次类推,直到所有进程完成。...
  • 该程序实现作业调度的RR算法,只要输入时间片,进程号,到达时间,运行所需时间即可,输出的是一条时间轴和对应的进程运行流程,表示一个时间点里哪个进程在运行。
  • 以下是本学期操作系统课程设计的题目,写这篇博客为了记录通过了紧张的向老师答辩,分享此实验编译后的程序,帮助其他人学习时间片轮转法,避免陷入理解的误区。本人自我感觉输出界面和相关信息已经很简明,功能相对...
  • 动态优先数加时间片轮转法实现进程调度,每运行一个时间片优先数减3,cpu时间加1,总时间减1. 所有想说的都在代码里 PCB.java package process; public class PCB { public int id; public int pri; public int...
  • 一、实验步骤1、在文档右边的虚拟化操作系统中,打开桌面的 Xfce 终端,输入cd Desktop2、输入touch 4-1.c3、输入gedit 4-1.c4、在 gedit 里面输入源代码,点击 save 保存5、关掉 gedit 编辑器6、输入gcc -o 4-1 4-1...
  • 设计一个按照时间片轮转法实现处理机调度的程序。 实验内容 (1) 假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且参数意义也相同。 进程名 链接指针 到达...
  • 要求: ...采用时间片轮转法代码:#include #include using namespace std;//设置进程的数目 static int const MAXNUM=5;//设计进程类 class process{ public: char processName;//进程的名称 int t
  • 题目一:设计一个按照时间片轮转法实现处理机调度的程序 时间片轮转法实现处理机调度的程序设计提示如下: (1)假设系统有n个进程,每个进程用一个进程控制块(PCB)来代表。进程控制块的格式如下表所示,且参数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,128
精华内容 2,051
关键字:

时间片轮转法代码