进程调度模拟设计——先来先服务、优先级法复习过程
1实验一先来先服务FCFS和短作业优先SJF进程调度算法
实验一先来先服务FCFS和短作业优先SJF进程调度算法一：需求分析程序设计的任务：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n个x进程分别在T1，… ,Tn时刻到达系统,它们需要的服务时间分别为S1，… ，Sn.分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
（1）输入的形式和输入值的范围为免去测试时候需要逐步输入数据的麻烦,输入时采用输入文件流方式将数据放在。
txt 文件中，第一行为进程个数，第二行为进程到达时间（各个进程的到达时间之间用空格隔开），第三行为进程的服务时间（每个服务时间之间用空格隔开）。
（2）输出的形式模拟整个调度过程，输出每个时刻的进程运行状态，同时输出了每个进程的完成时间，并且按要求输出了计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
（3）程序所能达到的功能能够模拟出进程的先来先服务FCFS算法和短作业优先SJF算法的调度过程，输入进程个数n；每个进程的到达时间T1, … ，Tn和服务时间S1, … ,Sn;选择算法1-FCFS,2-SJF,3—退出，用户做出选择即可输出对应的算法调度过程或者退出程序。
（4）测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果测试数据及其输出结果:二:概要设计程序包括主函数、FCFS算法函数、SJF算法函数、输出函数;主函数流程：输入文件中的数据—显示各进程数据-选择算法-调用相应算法的函数-输出结果三：详细设计算法流程图：调用结束四:调试分析(1)：调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析;开始的时候没有判断进程是否到达，导致短进程优先算法运行结果错误，后来加上了判断语句后就解决了改问题。
先来先服务,时间片调度,优先级调度算法实验报告
先来先服务,时间片调度,优先级调度算法实验报告实验报告1. 引言进程调度是操作系统中非常重要的一部分，它决定了进程在CPU上执行的顺序和时间长度。
在本次实验中，我们通过实现先来先服务调度算法、时间片调度算法和优先级调度算法，并对其性能进行比较，来深入了解各种调度算法的工作原理及优缺点。
2. 先来先服务调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。
当一个进程到达时，如果CPU空闲，则将其分配给CPU进行执行；如果CPU 正在执行其他进程，则该进程将等待直到CPU空闲。
优点是简单易实现，适用于长作业。
缺点是可能出现饥饿现象，即低优先级的进程可能会一直等待高优先级进程的执行。
3. 时间片调度算法时间片调度算法将CPU的执行时间划分为固定长度的时间片，每个进程在一个时间片内执行，当时间片用完后，系统将切换到下一个进程执行。
该算法确保每个进程都有公平的执行时间，避免了饥饿现象。
然而，对于CPU利用率较高的情况下，可能会导致进程频繁地切换，增加了上下文切换的开销。
4. 优先级调度算法优先级调度算法根据进程的优先级来进行调度，优先级较高的进程将具有更高的执行优先级。
当多个进程同时到达CPU时，系统将选择优先级最高的进程先执行。
该算法可以分为静态优先级调度和动态优先级调度两种方式。
优点是可以根据进程的重要性灵活调整执行顺序。
缺点是可能导致优先级低的进程长时间等待，造成饥饿现象。
5. 实验结果与分析我们通过模拟多个进程的到达和执行过程，在不同的场景下比较了先来先服务调度算法、时间片调度算法和优先级调度算法的性能。
实验结果显示，在长作业的情况下，先来先服务调度算法表现较好；在要求公平性的场景下，时间片调度算法比较适合；而对于需要根据优先级来调度的场景，优先级调度算法可以更好地满足需求。
6. 结论不同的进程调度算法在不同的场景下有各自的优劣。
先来先服务调度算法简单易实现，适用于长作业；时间片调度算法保证了公平性，适用于要求公平的场景；而优先级调度算法则可以根据进程的重要性进行调度。
实验 先来先服务FCFS进程调度模拟
实验先来先服务FCFS进程调度模拟一、实验目的二、模拟单处理器系统的进程调度，采用先来先服务的进程调度算法作为进程设计算法，以加深对进程的概念及进程调度算法的理解．二、实验内容启动VC6，新建一个win32 console application 工程,工程名称:操作系统FCFS实验，如图所示：确定后选新建一个空工程再新建一个C++ Source File文件：文件名:FCFS算法模拟下面程序就是一个FCFS进程调度的模拟，请仔细研究，体会，消化。
运行时请按教材P90 表4-2 所示，输入5个进程的进程名，到达时间，完成时间，观察结果情况。
#include <stdio.h>#include <string.h>#include <stdlib.h>#include <conio.h>#define N 5struct PCB{char name[8];int arrive_time;int run_time;int finish_time;int zhouzhuan_time;};int total=0;struct PCB pcb[N],temp;void output(){printf("----------------------------------------------------------------------------------------------\n");printf("进程名到达时间运行时间完成时间周转时间 \n");printf("----------------------------------------------------------------------------------------------\n");for(int i=0;i<N;i++){printf(" %s %d %d %d %d \n",pcb[i].name,pcb[i].arrive_time,pcb[i].run_time,pcb[i].finish_time,pcb[i].zhouzhuan_time);}printf("----------------------------------------------------------------------------------------------\n");}void main(){int i,j;for ( i=0;i<N;i++){printf("请输入进程名\n" );scanf("%s",pcb[i].name);printf("请输入到达时间:");scanf("%d",&pcb[i].arrive_time);printf("请输入要运行时间");scanf("%d",&pcb[i].run_time);}for( i=0;i<N;i++){ printf("%s ",pcb[i].name);printf("%d ",pcb[i].arrive_time);printf("%d \n",pcb[i].run_time);}pcb[0].finish_time=pcb[0].arrive_time+pcb[0].run_time;pcb[0].zhouzhuan_time=pcb[0].finish_time-pcb[0].arrive_time;for(i=1;i<N;i++){pcb[i].finish_time=pcb[i-1].finish_time+pcb[i].run_time;pcb[i].zhouzhuan_time=pcb[i].finish_time-pcb[i].arrive_time;}output();}要求：（下面的要求一个一个实现）1.上面程序没有求每个进程的带权周转时间、平均周转时间，平均带权周转时间，能否加上，结果输出的格式按类似P90表4-2 输出。
先来先服务和短进程优先调度算法模拟课程设计
资料范本本资料为 word 版本，可以直接编辑和打印，感谢您的下载先来先服务和短进程优先调度 算法模拟课程设计地点：__________________ 时间：__________________说明：本资料适用于约定双方经过谈判，协商而共同承认，共同遵守的责任与义 务，仅供参考，文档可直接下载或修改，不需要的部分可直接删除，使用时请详 细阅读内容课程设计（论文）题 目: 先来先服务和短进程优先调度算法模拟院 （系）： 华清学院专业班级： 计算机 2011姓 名：王江学 号：11指导教师：曾应员2013 年 12 月 18 日西安建筑科技大学华清学院课程设计（论文）任务书专业班级： 计算机1101 学生姓名： 王江 指导教师（签名）：一、课程设计（论文）题目先来先服务和短进程优先调度算法模拟（进程调度）：编写一个进程调度程序， 允许多个进程并行执行，并能选择是先来先服务算法还是短进程优先算法。
二、本次课程设计（论文）应达到的目的操作系统课程实践性比较强。
课程设计是加强学生实践能力的一个强有力手段。
课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。
严格实施课 程设计这一环节，对于学生基本程序设计素养的培养和软件工作者工作作风的训练， 将起到显著的促进作用。
本题目要达到目的：深入掌握进程调度的概念原理和实现方法。
三、本次课程设计（论文）任务的主要内容和要求（包括原始数据、技术 参数、设计要求等）先来先服务调度算法是以进程的到达时间为判断标准，按各个进程所的到达时间 先后顺序进行调度。
短进程优先调度算法是按进程的预计运行时间长短进行排序，先 执行短进程。
四、应收集的资料及主要参考文献：操作系统经典算法的编程实现资料非常丰富，可以在图书馆找书籍或在因特网上 找资料，都很容易找到，但是大部分代码是不全的，不能直接运行，希望大家只是把 它当参考，编码还是自己做。
参考文献： 【1】汤小丹、梁红兵、哲凤屏、汤子瀛 编著.计算机操作系统（第三版）.西安： 西安电子科技大学出版社，2007.5 【2】史美林编.计算机操作系统教程.北京：清华大学出版社，1999.11 【3】徐甲同编著.操作系统教程.西安：西安电子科技大学出版社，1996.8【4】Clifford，A.Shaffer 编著.数决结构与算法分析(C++版).北京：电子工业出版社，2005.7 【5】蒋立翔编著.C++程序设计技能百练.北京：中国铁道出版社，2004.1五、审核批准意见教研室主任（签字）设计总说明能够选择不同的调度算法（先来先服务，非强占式短进程优 先算法），通过给出进程名、进程的到达时间和进程的运行时间， 根据调度算法计算出进程的平均周转时间和平均带权周转时间， 比较调度算法的优劣。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
四种进程调度算法 先到先服务,优先级,短作业优先,时间片轮转
#include"stdio.h"#define N 50int n;int sj;struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int yxj; //优先级int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];void input(Gzuo a[]){printf("请输入进程个数：");scanf("%d",&n);for(int i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sj);}void sjp(Gzuo a[],int sj)//时间片轮转调度{int i,j,min,time;float sum1,sum2;bool flag=true;/*printf("\t请输入进程数(0<n<=50):\t"); scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入：");scanf("%d",&sjp);}/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf("赋值后TIME值为：%d\n",time);min = 0;while(min<n){flag=true;for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag=false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf("当前a[%d].st2值为：%d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sj;//printf("运算后当前a[%d].st2值为：%d\n",i,a[i].st2); //printf("当前TIME值为：%d\n",time);time = time + sj;//printf("增加之后TIME值为：%d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag)for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("**************************************************************** *****\n");}void fcfs(Gzuo a[])//先到先服务调度{int i,j,min;float sum1,sum2;/*printf("\t请输入进程数(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0)printf("n\t请重新输入："); scanf("%d",&n);}printf("\n\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void sjf(Gzuo a[])//短作业优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t"); scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void yxj(Gzuo a[])//优先级优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/* struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间："); scanf("%d",&a[i].dt);printf("\t服务时间："); scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min; min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n"); sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i ].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void main(){ int n;input(a);printf("以下是先到先服务调度：");fcfs(a);printf("以下是短作业优先调度：");sjf(a);printf("以下是时间片轮转法：");sjp(a,sj);printf("以下是优先级优先调度：");yxj(a); }。
操作系统课设-进程调度模拟设计(先来先服务、优先级法)
cout<<"进程运行时间：";
cin>>r;
cout<<"进程到达时间：";
cin>>a;
cout<<"进程优先级：";
cin>>p;
cout<<endl;
Node *tp;
tp=new Node;
tp->num=n;
tp->name=na;
tp->run_time=r;
tp->arrive_time=a;
<<setw(12)<<"结束时间"<<endl;
while(tp!=NULL){
cout<<" "<<setw(10)<<tp->num<<setw(10)<<tp->name
<<setw(12)<<tp->arrive_time<<setw(12)<<tp->run_time;
cout<<setw(12)<<tp->start_time<<setw(12)<<tp->end_time<<endl;
q->priority=tp->priority;
q->next=NULL;
tp=tp->next;
p=temp;
while( p->next!=NULL && p->next->priority < q->priority){
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有5个进程要运行在一个单核处理器上，每个进程有不同的运行时间和优先级。
进程信息如下：进程A：运行时间10ms，优先级4进程B：运行时间8ms，优先级3进程C：运行时间6ms，优先级2进程D：运行时间4ms，优先级1进程E：运行时间2ms，优先级5实验步骤：1.先来先服务（FCFS）调度算法实验：将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
2.最短作业优先（SJF）调度算法实验：将上述进程按照运行时间的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
3.优先级调度算法实验：将上述进程按照优先级的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
4.时间片轮转（RR）调度算法实验：设置一个时间片大小，将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
实验结果：通过模拟实验，我们可以得到每个进程的运行时间、完成时间和等待时间。
对于FCFS算法，进程的运行顺序是按照先来先服务的原则，因此进程A首先得到处理器资源并完成运行，其它进程依次按照到达顺序得到资源。
因此，对于进程A、B、C、D、E，它们的完成时间分别是10ms、18ms、24ms、28ms和30ms，等待时间分别是0ms、10ms、18ms、24ms和28ms。
对于SJF算法，进程的运行顺序是按照运行时间的大小，即短作业优先。
因此，进程E首先得到处理器资源并完成运行，其它进程依次按照运行时间的大小得到资源。
对于进程E、D、C、B、A，它们的完成时间分别是2ms、6ms、12ms、20ms和30ms，等待时间分别是0ms、2ms、6ms、12ms和20ms。
进程调度先来先服务时间片轮转法优先服务调
进程调度先来先服务时间片轮转法优先服务调度处理器调度免费下载C或C++/*标题：设计一：进程调度设计目的：进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。
在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的进程调度，目的是加深对进程调度工作的理解，掌握不同调度算法的优缺点。
设计题目：设计一个按先来先服务，算法时间片轮转法，优先数调度算法实现处理器调度的程序。
*//*亲爱的同学们，大家好。
欢迎访问我的百度空间，在此我向大家提供免费的资料，这是我们实习要做的。
主要是因为我看到很多下载都要金币，而我自己没有金币，不爽。
现在我提供免费下载，做个好人。
复制到VC++时可能有些格式问题，稍微修改一下就OK了，程序本身不存在问题的。
大三第一个学期实习的哦*//*先来先服务：是一种最简单的调度算法，每次调度都从后备作业或者进程当中选择一个或者多个最先进入该队列的作业或进程，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
当调用FCFS算法时，系统为它们分配处理机，让它们运行。
该算法的优点是比较利于长作业（进程），而缺点是不利于短作业（进程）。
算法时间片轮转法：系统将所有的就绪进程按照先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
当执行完时间片时，计时器就会发出中断请求，调度程序就会停止该进程的执行，并把它送往就绪队列的末尾；然后再把处理机分配给就绪队列中新的队首进程，同时也分配时间片给它。
这样保证就绪队列中的所有进程在一个给定的时间片当中都能够获得一个时间片的处理机执行时间。
而时间片的大小最好取适中的，即略大于一次典型的交互所需时间。
优先数调度算法：该方法又分成两种算法分支，分别是非抢占式优先权算法和抢占式优先权调度算法。
先来先服务,时间片调度,优先级调度算法实验报告
先来先服务,时间片调度,优先级调度算法实验报告先来先服务、时间片调度、优先级调度算法实验报告1. 引言本次实验旨在研究和比较先来先服务（FCFS）、时间片调度（RR）和优先级调度（Priority Scheduling）三种常见的进程调度算法。
进程调度是操作系统中的重要概念之一，合理的进程调度算法可以提高系统效率，优化资源利用。
2. 先来先服务算法•先来先服务算法是一种简单的调度算法，按照进程到达的顺序进行调度。
•优点：简单易实现，适用于长作业。
•缺点：容易造成短作业等待时间过长，无法满足实时性要求。
3. 时间片调度算法•时间片调度算法将CPU时间划分为一段一段的时间片，每个进程在一个时间片内执行。
•若进程未完成，会被放入就绪队列的末尾，等待下一个时间片。
•优点：公平，适用于短作业，能满足实时性要求。
•缺点：时间片过长，会导致长作业等待时间过长。
4. 优先级调度算法•优先级调度算法根据进程的优先级来确定调度顺序，拥有最高优先级的进程先执行。
•静态优先级可在创建进程时确定，动态优先级可根据进程执行情况进行调整。
•优点：适用于实时任务和长作业，可根据需求调整优先级。
•缺点：可能导致低优先级任务等待时间过长，存在优先级反转问题。
5. 实验结果与分析通过对三种调度算法的实验测试，得出以下结论：•FCFS算法在长作业的情况下表现较好，但对于短作业不友好，容易造成长时间等待；•RR算法适用于短作业，能保证公平性，但时间片过长可能导致长作业等待时间过长；•优先级调度算法较为灵活，能满足实时性要求，但可能导致低优先级任务长时间等待。
综上所述，不同的调度算法适用于不同的场景，根据需求选择合适的算法可提高系统效率。
6. 总结本次实验对先来先服务、时间片调度和优先级调度算法进行了研究和比较。
通过对三种算法的分析，我们可以根据任务特点和需求选择合适的调度算法，以提高系统的效率和资源利用率。
同时，在实际应用中也需要考虑进程的实时性要求，避免长时间等待等问题的出现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程调度模拟设计——先来先服务、优先级法学号：课程设计题目进程调度模拟设计——先来先服务、优先级法学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名：专业班级：指导教师：吴利军工作单位：计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日进程调度模拟设计——先来先服务、优先级法1、背景：当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。
只要有两个或更多的进程处于就绪状态，这种情形就会发生。
如果只有一个CPU可用，那么就必须选择下一个要运行的进程。
在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。
进程调度的核心问题是采用什么样的算法把处理机分配给进程，好的算法将提高资源利用率，减少处理机的空闲时间，避免有些作业长期得不到相应的情况发生等，从而设计出受欢迎的操作系统。
较常见的几种进程调度算法有：先来先服务调度算法；短作业优先调度算法；时间片轮转调度算法；优先级调度算法；高响应比优先算法和多级反馈队列调度算法等。
2、需求分析：2.1设计目的无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。
另外，系统进程也同样需要使用处理机。
这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
本次课程设计的主要任务是用高级语言模拟进程调度的算法，包括先来先服务和优先级法。
通过输入进程的信息，模拟某种调度算法，得到进程调度的顺序，从而进一步分析进程的调度过程，并通过分析程序的运行，探讨各种调度算法的优劣。
2.2 设计内容及要求本系统运用高级语言来实现对进程调度的模拟。
系统需要完成的功能有：①进程信息的输入，包括进程的个数、进程名、进程优先级、进程开始时间、进程执行时间等。
②进程调度算法的选择，即为用户提供可选的进程调度算法，用户可以根据需要选择调度算法。
③根据进程调度的算法和输入的进程信息得到进程的调度顺序，并输出。
④计算并输出各个进程的平均周转时间和平均带权周转时间。
2.3算法与设计的思想2.3.1算法思想：·一个进程的生命期可以划分为一组状态，这些状态刻画了整个进程。
系统根据PCB结构中的状态值控制过程。
在进程的生命期内，一个进程至少具有5种基本状态，它们是：初始态、执行状态、等待状态、就绪状态和终止状态。
通过系统设计，实现进程相关数据结构的创建和查看功能；实现多种进程调度算法：先来先服务算法、优先级调度算法、时间片轮转法等；实现对执行进程的阻塞，对等待进程的唤醒等功能。
进程的转换过程如下：·进程的先来先服务调度算法：首先定义进程结构体，用于记录进程的基本信息，包括进程名，优先级，进程到达时间，进程运行时间，然后将用户输入的进程信息保存到定义的结构数组中，并按进程到达的先后时间对数组进行排序，并记录它们的周转时间、带权周转时间、平均周转时间及平均带权周转时间。
·进程的优先级调度算法：同样先定义进程结构替，记录进程信息，将用户输入的进程信息保存在结构体数组中。
遍历数组，找出最先到达的进程，若有多个，则取优先级最高的一个，与数组中的第一个位置的进程互换位置，记录此进程执行完的时间，然后从第二个位置开始遍历数组，找到在第一个进程执行结束前到达的进程，若没有，则找到余下进程中到达时间最早的进程，找到优先级最高的一个，若并与数组的第二个位置的进程互换位置。
按同样的方法为余下的进程排序。
同样记录它们的周转时间，带权周转时间，并算出平均周转时间和平均带权周转时间。
2.3.2设计思想：a)每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先级数、到达时间、需要运行时间等等。
b)进程的信息，包括到达时间，优先数及需要的运行时间等都是事先人为地指定。
c)每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
3、功能设计（数据结构及模块说明）；3.1 系统流程如下：3.2数据结构及模块说明：（1）输入模块能够满足输入进程基本信息的功能，尽可能提供友好的交互界面。
给用户很好的提示，使用户能够方便的操作。
（2）算法模块先来先服务算法：可以根据进程到达的先后顺序来确定进程的运行顺序，并算出进程的周转时间，平均周转时间等。
优先级法：根据进程的优先级和进程到达的时间来确定进程的调度顺序，并算出周转时间，带权周转时间等。
（3）输出模块根据算法得到的进程调度顺序以及算出的其他参数，将其输出。
4、开发平台及源程序的主要部分；4.1软硬件环境●硬件设备： PC机●软件设备：WINDOWSXP、Microsoft Visual C++ 6.04.2 源代码主要部分：（1）信息输入函数：void getInput(char *pname,int *priority,char *begintime,float *runtime){printf("请输入进程名： ");scanf("%s",pname);printf("请输入优先级 ");scanf("%d",priority);printf("请输入到达时间：");scanf("%s",begintime);printf("请输入¨运行时间 (min)： ");scanf("%f",runtime);}（2）先来先服务的算法：void fcfs(struct process *pro,int n){int i,j;struct process p;for(i = 0;i < n;i ++){for(j = 0;j < n - i -1;j ++){if(!timecompare(pro[j],pro[j+1])){p = pro[j + 1];pro[j + 1] = pro[j];pro[j] = p;}}}}（3）优先级法的算法：void prior(struct process *pro,int n){int i,j,pt,t,bt,m;bt = 0;int a[MAXPROCESS];struct process p;float curtime = 1500; //当Ì¡À前¡ã时º¡À间? for(i = 0;i < n;i ++){if(curtime > pro[i].btime){curtime = pro[i].btime;}}for(i = 0;i < n;i ++){t = 0;pt = 0;for(j = i;j < n;j++){if(pro[j].btime <= curtime){a[t++] = j;}}if(t == 0){curtime = 1500;for(j = i;j < n;j ++){if(curtime > pro[j].btime){curtime = pro[j].btime;}}for(j = i;j < n;j++){if(pro[j].btime <= curtime){a[t++] = j;}}}for(j = 0;j < t;j++){bt = a[j];if(pro[bt].priority > pt){pt = pro[bt].priority;m = bt;}}if(m != i){p = pro[m];pro[m] = pro[i];pro[i] = p;}curtime = curtime + pro[i].runtime;}}5、测试用例，运行结果与运行情况分析；5.1测试用例：①进程个数为4②进程名唯一③预计运行结果：先来先服务：c a d b优先级法：c a b d进程名进程到达时间运行时间优先级a 2:12 34 2b 3:10 31 3c 1:15 21 1d 2:13 11 25.2运行结果：6、自我评价与总结：通过这次的课程设计熟悉了优先级法以及先来先服务算法在处理进程调度的问题上的应用，熟悉了它们各自的特点以及各自的优缺点。
在实验结果中可以看到优先级法在处理特殊进程问题上有很大的意义，可以有效地缩短平均周转时间以及平均带权周转时间，而先来先服务实现简单，两种方法各有所长。
在程序调试的过程中遇到了很多的麻烦，有时编译运行没有问题但结果不对，通过设置断点单步调试却发现只是丢了一个赋值或者拷贝时忘了某些内容，这些小错误耽误了不少时间，所以在以后的编程过程中要养成随时给变量赋初值的习惯。
有些在算法编制的过程中遇到的问题确实有点棘手，但是随着这些问题的解决又使自己在这一方面的能力上有了比较大的提高。
但是同时我仍然看到了自己的不足，与别人比起来仍然有不小的差距。
自己用的时间比别人长，但是效果又不如别人的好。
所以自己还应该继续努力。
本科生课程设计成绩评定表注：最终成绩以五级分制记。
优（90-100分）、良（80-89分）、中（70-79分）、及格（60-69分）、60分以下为不及格指导教师签名：20 年月日附录：#include"stdafx.h"#include"stdlib.h"#include"string.h"#define PNNUM 20#define TIME 6 //时º¡À间?的Ì?长¡è度¨¨#define MAXPROCESS 10// 进?程¨¬结¨¢构1struct process{char name[PNNUM]; //进?程¨¬名?int priority; //优®?先¨¨级?char begintime[TIME]; //开a始º?时º¡À间?int btime; //开a始º?时º¡À间?（ꡧ转Áa换?为a分¤?钟¨®）ê?float runtime; //运?行D时º¡À间?float routime; //周¨¹转Áa时º¡À间?float qtime; //带ä?权¨¡§周¨¹转Áa时º¡À间?}pro[MAXPROCESS];// 输º?入¨?进?程¨¬参?数ºyvoid getInput(char *pname,int *priority,char *begintime,float *runtime) {printf("请?输º?入¨?进?程¨¬名?：êo");scanf("%s",pname);printf("请?输º?入¨?优®?先¨¨级?：êo");scanf("%d",priority);printf("请?输º?入¨?到Ì?达ä?时º¡À间?：êo");scanf("%s",begintime);printf("请?输º?入¨?运?行D时º¡À间?(min)：êo");scanf("%f",runtime);}//将?开a始º?时º¡À间?转Áa换?为a分¤?钟¨®void ttoi(struct process *pro,int n){int h,m;char a[3],b[3];int i;for(i = 0;i < n; i ++){int j;for(j = 0;pro[i].begintime[j] != ':';j ++){a[j] = pro[i].begintime[j];}b[0] = pro[i].begintime[j + 1];b[1] = pro[i].begintime[j + 2];h = atoi(a); //得Ì?到Ì?小?时º¡Àm = atoi(b); //得Ì?到Ì?分¤?钟¨®pro[i].btime = h * 60 + m;}}//比À¨¨较?两¢?个?进?程¨¬到Ì?达ä?时º¡À间?,若¨?同ª?时º¡À到Ì?或¨°pro1早?到Ì?，ê?则¨°返¤¦Ì回?1int timecompare(struct process pro1,struct process pro2){return pro1.btime > pro2.btime ? 0 : 1;}//根¨´据Y进?程¨¬到Ì?达ä?时º¡À间?排?队¨®void fcfs(struct process *pro,int n){int i,j;struct process p;for(i = 0;i < n;i ++){for(j = 0;j < n - i -1;j ++){if(!timecompare(pro[j],pro[j+1])){p = pro[j + 1];pro[j + 1] = pro[j];pro[j] = p;}}}}//计?算?周¨¹转Áa时º¡À间?和¨ª带ä?权¨¡§周¨¹转Áa时º¡À间?void calculate(struct process *pro,int n){int i;pro[0].routime = pro[0].runtime;pro[0].qtime = 1;for(i = 1;i < n;i ++){if(pro[i - 1].btime + pro[i - 1].routime >= pro[i].btime)pro[i].routime =pro[i - 1].btime + pro[i - 1].routime + pro[i].runtime - pro[i].btime;elsepro[i].routime = pro[i].runtime;pro[i].qtime = pro[i].routime / pro[i].runtime;}}//计?算?平?均¨´周¨¹转Áa时º¡À间?和¨ª平?均¨´带ä?权¨¡§周¨¹转Áa时º¡À间? void calAver(struct process *pro,int n,float *avartime,float *avarqtime) {int i;float t1,t2;t1 = t2 = 0;for(i = 0;i < n;i++){t1 += pro[i].routime;t2 += pro[i].qtime;}*avartime = t1 / n;*avarqtime = t2 / n;}//非¤?抢¨¤占?式º?优®?先¨¨级?法¤¡§void prior(struct process *pro,int n){int i,j,pt,t,bt,m;bt = 0;int a[MAXPROCESS];struct process p;float curtime = 1500; //当Ì¡À前¡ã时º¡À间?for(i = 0;i < n;i ++){if(curtime > pro[i].btime){curtime = pro[i].btime;}}for(i = 0;i < n;i ++){t = 0;pt = 0;for(j = i;j < n;j++){if(pro[j].btime <= curtime){a[t++] = j;}}if(t == 0){curtime = 1500;for(j = i;j < n;j ++){if(curtime > pro[j].btime){curtime = pro[j].btime;}}for(j = i;j < n;j++){if(pro[j].btime <= curtime){a[t++] = j;}}}for(j = 0;j < t;j++){bt = a[j];if(pro[bt].priority > pt){pt = pro[bt].priority;m = bt;}}if(m != i){p = pro[m];pro[m] = pro[i];pro[i] = p;}curtime = curtime + pro[i].runtime;}}void print(struct process *pro,int n,float f1,float f2){int i;printf("进?程¨¬调Ì¡Â度¨¨顺3序¨°为a：êo\n");printf("-----------------------------------------------------------\n");printf("调Ì¡Â度¨¨顺3序¨°优®?先¨¨级? 到Ì?达ä?时º¡À间? 运?行D时º¡À间? 周¨¹转Áa时º¡À间? 带ä?权¨¡§周¨¹转Áa时º¡À间?\n");for(i = 0;i < n;i ++){printf("%8s %6d %8s %8.0f %8.0f %12.2f\n",pro[i].name,pro[i].priority,pr o[i].begintime,pro[i].runtime,pro[i].routime,pro[i].qtime);}printf("-----------------------------------------------------------\n");printf("平?均¨´周¨¹转Áa时º¡À间?：êo\t%0.2f\t",f1);printf("平?均¨´带ä?权¨¡§周¨¹转Áa时º¡À间?：êo\t%0.2f\t\n",f2);printf("-----------------------------------------------------------\n");}int _tmain(int argc, _TCHAR* argv[]){printf("*********************\n");printf("* 进?程¨¬调Ì¡Â度¨¨模¡ê拟a实º¦Ì验¨¦ *\n");printf("*********************\n");int pronum =0;int go = 1;int input1 = 1;int input2 = 1;float f1,f2;f1 = f2 = 0;while(go == 1){printf("请?输º?入¨?进?程¨¬数ºy(最Á?大䨮进?程¨¬数ºy位?为a10)：êo");scanf("%d",&pronum);int n;for(n = 0;n < pronum;n ++){printf("进?程¨¬:%d:\n",n+1);printf("---------------------------------\n");getInput(pro[n].name,&pro[n].priority,pro[n].begintime,&pro[n].runtime);printf("---------------------------------\n");}while(input2 == 1){printf("****************************\n");printf("*请?选?择?调Ì¡Â度¨¨算?法¤¡§：êo \n");printf("*先¨¨来¤¡ä先¨¨服¤t务? --1 \n");printf("*优®?先¨¨级?法¤¡§（ꡧ非¤?抢¨¤占?）ê? --2\n");printf("****************************\n");printf("请?选?择?：êo");scanf("%d",&input1);ttoi(pro,pronum);switch(input1){case 1:fcfs(pro,pronum);break;case 2:prior(pro,pronum);break;}calculate(pro,pronum);calAver(pro,pronum,&f1,&f2);print(pro,pronum,f1,f2);printf("是º?否¤?重?新?选?择?算?法¤¡§：êo 是º?: 1 否¤?: 0\n");scanf("%d",&input2);}printf("是º?否¤?继¨¬续?：êo 继¨¬续?: 1 退ª?出?: 0\n");scanf("%d",&go);}return 0;}。