精华内容
下载资源
问答
  • 当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以...

    一 定义

    时间片轮转算法是将所有的就绪进程按先来先服务的原则,排成一个队列,按时间片轮转。时间片的大小从几ms到几百ms。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间。


    二 代码

    进程类如下:

    import java.util.Iterator;
    import java.util.Scanner;
    import java.util.TreeSet;
    
    public class Process implements Comparable<Process>{                        
        private String ProcessName;             //进程名
        private int ReachTime;                  //到达时间
        private int ProcessTime;                //处理时间
        private int FinishTime;                 //完成时间
        private int PeriodTime;                 //周转时间
        private int StartTime;                  //开始时间
        private double WeightedPeriodTime;      //带权周转时间
        private int Priority;                   //优先级
    
        public Process(String processname,int reachTime, int processTime) {
            super();
            ProcessName = processname;
            ReachTime = reachTime;
            ProcessTime = processTime;
        }
    
        public Process(String processName, int reachTime, int processTime, int priority) {
            super();
            ProcessName = processName;
            ReachTime = reachTime;
            ProcessTime = processTime;
            Priority = priority;
        }
    
        public int getPriority() {
            return Priority;
        }
    
        public String getProcessName() {
            return ProcessName;
        }
    
        public int getReachTime() {
            return ReachTime;
        }
    
        public int getProcessTime() {
            return ProcessTime;
        }
    
        public int getFinishTime() {
            return FinishTime;
        }
    
        public int getPeriodTime() {
            return PeriodTime;
        }
    
        public void setProcessTime(int processTime) {
            ProcessTime = processTime;
        }
    
        public void setFinishTime(int finishTime) {
            FinishTime = finishTime;
        }
    
        public void setPeriodTime(int periodTime) {
            PeriodTime = periodTime;
        }
    
        public int getStartTime() {
            return StartTime;
        }
    
        public void setStartTime(int startTime) {
            StartTime = startTime;
        }
    
        public double getWeightedPeriodTime() {
            return WeightedPeriodTime;
        }
    
        public void setWeightedPeriodTime(double weightedPeriodTime) {
            WeightedPeriodTime = weightedPeriodTime;
        }
    
        @Override
        public int compareTo(Process o) {
            // TODO Auto-generated method stub
            if ( this.ReachTime > o.ReachTime)
                return 1;
            else if ( this.ReachTime < o.ReachTime)
                return -1;
            return 0;
        }
    
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ReachTime;
            return result;
        }
    
        public void Print(){
            System.out.print(this.ProcessName+" "+this.ReachTime+"  "+this.ProcessTime+"    "+" "+this.StartTime+"  "+this.FinishTime+" "+this.PeriodTime+" ");
            System.out.printf("%.4f",this.WeightedPeriodTime);
            System.out.println();
        }
    }

    时间片轮转算法实现如下:

    import java.util.Collection;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.Scanner;
    import java.util.TreeSet;
    
    public class RR {
        private TreeSet<Process> process = new TreeSet<Process>();
    
        public RR() {
            System.out.println("请输入要添加的进程数:");
            Scanner in = new Scanner(System.in);
            int Num = in.nextInt();
            System.out.println("开始初始化进程信息(进程名 到达时间 耗时):");
            for ( int i = 0 ; i < Num ; i++){
                String processname = in.next();
                int reachtime = in.nextInt();
                int processtime = in.nextInt();
                Process p = new Process(processname,reachtime, processtime); 
                process.add(p);
            }
        }
    
        public TreeSet<Process> getProcess() {
            return process;
        }
    
        public void CarryOut_RR(int Timeperiod){
            LinkedList<Process> Tmp = new LinkedList<>();
            LinkedList<Process> ProcessSeries = new LinkedList<Process>();
            LinkedList<Process> FinsishProcess = new LinkedList<Process>();
            LinkedList<Integer> processtime = new LinkedList<Integer>();
            Iterator<Process> it = this.process.iterator();
            while(it.hasNext()){
                Process p = it.next();
                Tmp.add(p);
                processtime.add(p.getProcessTime());
            }
            int NowTime = Tmp.peekFirst().getReachTime();                       //当前时间
            int NowProcessTime = processtime.pop();
            //第一个进程特殊情况
            Process p = Tmp.pop();
            p.setStartTime(NowTime);
            p.setFinishTime(p.getFinishTime()+Timeperiod);
            p.setPeriodTime(p.getFinishTime() - p.getReachTime());
            p.setWeightedPeriodTime(p.getPeriodTime() * 1.0 / p.getProcessTime());
            NowTime += Timeperiod;
            int FinishTime = p.getFinishTime();                                 //完成时间
            NowProcessTime -= Timeperiod;
            if ( NowProcessTime > 0){
                ProcessSeries.add(p);
                processtime.add(NowProcessTime);
            }else{
                if ( NowProcessTime < 0){
                    p.setFinishTime(p.getFinishTime() + NowProcessTime);
                    p.setPeriodTime(p.getFinishTime() - p.getReachTime());
                    p.setWeightedPeriodTime(p.getPeriodTime() * 1.0 / p.getProcessTime());
                    NowTime += NowProcessTime;
                    FinishTime = p.getFinishTime();
                }
                FinsishProcess.add(p);
            }
            //时间轮转法
            int len = this.process.size() - 1;
            for ( int i = 0 ; i < len ; i++){
                p = Tmp.pop();
                NowProcessTime = processtime.pop();
                if ( NowTime >= p.getReachTime())
                p.setStartTime(NowTime);
                p.setFinishTime(Timeperiod + FinishTime);
                p.setPeriodTime(p.getFinishTime() - p.getReachTime());
                p.setWeightedPeriodTime(p.getPeriodTime() * 1.0 / p.getProcessTime());
                FinishTime = p.getFinishTime();
                NowTime += Timeperiod;
                NowProcessTime -= Timeperiod;
                if ( NowProcessTime > 0){
                    ProcessSeries.add(p);
                    processtime.add(NowProcessTime);
                }else{
                    if ( NowProcessTime < 0){
                        p.setFinishTime(p.getFinishTime() + NowProcessTime);
                        p.setPeriodTime(p.getFinishTime() - p.getReachTime());
                        p.setWeightedPeriodTime(p.getPeriodTime() * 1.0 / p.getProcessTime());
                        NowTime += NowProcessTime;
                        FinishTime = p.getFinishTime();
                    }
                    FinsishProcess.add(p);
                }
            }
            while ( !processtime.isEmpty()){
                p = ProcessSeries.pop();
                NowProcessTime = processtime.pop();
                p.setFinishTime(Timeperiod + FinishTime);
                p.setPeriodTime(p.getFinishTime() - p.getReachTime());
                p.setWeightedPeriodTime(p.getPeriodTime() * 1.0 / p.getProcessTime());
                FinishTime = p.getFinishTime();
                NowProcessTime -= Timeperiod;
                if ( NowProcessTime > 0){
                    ProcessSeries.add(p);
                    processtime.add(NowProcessTime);
                }else{
                    if ( NowProcessTime < 0){
                        p.setFinishTime(p.getFinishTime() + NowProcessTime);
                        p.setPeriodTime(p.getFinishTime() - p.getReachTime());
                        p.setWeightedPeriodTime(p.getPeriodTime() * 1.0 / p.getProcessTime());
                        FinishTime = p.getFinishTime();
                    }
                    FinsishProcess.add(p);
                }
            }
    
            this.Print(FinsishProcess);
            System.out.printf("平均周转时间:%.4f",this.Avg_ProcessTime(FinsishProcess));
            System.out.println();
            System.out.printf("平均带权周转时间:%.4f",this.Avg_WeightedProcessTime(FinsishProcess));
            System.out.println();
        }
    
        public double Avg_ProcessTime(Collection<Process> FinsishProcess){                      //平均周转时间
            double avg = 0;
            Iterator<Process> it = this.process.iterator();
            while( it.hasNext()){
                Process p = it.next();
                avg += p.getPeriodTime();
            }
            avg /= this.process.size();
            return avg;
        }
    
        public double Avg_WeightedProcessTime(Collection<Process> FinsishProcess){                      //平均带权周转时间
            double avg = 0;
            Iterator<Process> it = this.process.iterator();
            while( it.hasNext()){
                Process p = it.next();
                avg += p.getWeightedPeriodTime();
            }
            avg /= this.process.size();
            return avg;
        }
    
        public void Print(Collection<Process> FinsishProcess){
            System.out.println("            调度示意图");
            System.out.println("进程  到达时间    耗时  开始时间    完成时间    周转时间    带权周转时间");
            Iterator<Process> it = FinsishProcess.iterator();
            while( it.hasNext()){
                Process p = it.next();
                p.Print();
            }
        }
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            RR rr = new RR();
            rr.Print(rr.getProcess());
            System.out.println("请输入时间片:");
            Scanner in = new Scanner(System.in);
            int Timeperiod = in.nextInt();                                      //时间片
            rr.CarryOut_RR(Timeperiod);
            in.close();
        }
    
    }
    
    展开全文
  • 转自:https://blog.csdn.net/houchaoqun_xmu/article/details/55540250时间片轮转RR进程调度算法一、概念介绍和案例解析时间片轮转法 - 基本原理:在早期的时间片轮转法中,系统将...当执行的时间片用完时,由一个计...

    转自:https://blog.csdn.net/houchaoqun_xmu/article/details/55540250

    时间片轮转RR进程调度算法

    一、概念介绍和案例解析

    时间片轮转法 - 基本原理:

    在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之,系统能在给定的时间内响应所有用户的请求。

    时间片轮转法 - 时间片大小的确定:

    在时间片轮转算法中,时间片的大小对系统性能有很大的影响,如选择很小的时间片将有利于短作业,因为它能较快地完成,但会频繁地发生中断、进程上下文的切换,从而增加系统的开销;反之,如选择太长的时间片,使得每个进程都能在一个时间片内完成,时间片轮转算法便退化为FCFS算法,无法满足交互式用户的需求。一个较为可取的大小是,时间片略大于一次典型的交互所需要的时间。这样可使大多数进程在一个时间片内完成。

    案例解析:

    (如上gif图是由GifCam软件制作)

    所下图所示为q=1和q=4时各进程的平均周转时间和带权平均周转时间,图中的RR(Round Robin)表示轮转调度算法。

    展开全文
  • 时间片轮转RR进程调度算法 一、概念介绍和案例解析时间片轮转法 - 基本原理: 在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度,把CPU分配给队首...当执行的时间片用完...

    转自:https://blog.csdn.net/houchaoqun_xmu/article/details/55540250

    时间片轮转RR进程调度算法

    一、概念介绍和案例解析
    时间片轮转法 - 基本原理:
      在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之,系统能在给定的时间内响应所有用户的请求。

    时间片轮转法 - 时间片大小的确定:
      在时间片轮转算法中,时间片的大小对系统性能有很大的影响,如选择很小的时间片将有利于短作业,因为它能较快地完成,但会频繁地发生中断、进程上下文的切换,从而增加系统的开销;反之,如选择太长的时间片,使得每个进程都能在一个时间片内完成,时间片轮转算法便退化为FCFS算法,无法满足交互式用户的需求。一个较为可取的大小是,时间片略大于一次典型的交互所需要的时间。这样可使大多数进程在一个时间片内完成。

    案例解析:

     

    (如上gif图是由GifCam软件制作)
      

    所下图所示为q=1和q=4时各进程的平均周转时间和带权平均周转时间,图中的RR(Round Robin)表示轮转调度算法。

     

     

    转载于:https://www.cnblogs.com/kangxinxin/p/9829543.html

    展开全文
  • 当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序根据这个请求停止该进程的运行,将它送到就绪队列的末尾,再把处理机分给就绪队列中新的队列首进程,同时让它也执行一个时间片。 多级反馈队列调度:...

    时间片轮转:

    时间片轮转算法的基本思想是,系统将所有的就绪进程按先来先服务算法的原则,排成一个队列,每次调度时,系统把处理机分配给队列首进程,并让其执行一个时间片。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序根据这个请求停止该进程的运行,将它送到就绪队列的末尾,再把处理机分给就绪队列中新的队列首进程,同时让它也执行一个时间片。
    

    多级反馈队列调度:

    1、进程在进入待调度的队列等待时,首先进入优先级最高的Q1等待。
    2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程,则调度次优先级队列中的进程。例如:Q1,Q2,Q3三个队列,当且仅当在Q1中没有进程等待时才去调度Q2,同理,只有Q1,Q2都为空时才会去调度Q3。
    3、对于同一个队列中的各个进程,按照FCFS分配时间片调度。比如Q1队列的时间片为N,那么Q1中的作业在经历了N个时间片后若还没有完成,则进入Q2队列等待,若Q2的时间片用完后作业还不能完成,一直进入下一级队列,直至完成。
    4、在最后一个队列QN中的各个进程,按照时间片轮转分配时间片调度。
    5、在低优先级的队列中的进程在运行时,又有新到达的作业,此时须立即把正在运行的进程放回当前队列的队尾,然后把处理机分给高优先级进程。换而言之,任何时刻,只有当第1~i-1队列全部为空时,才会去执行第i队列的进程(抢占式)。特别说明,当再度运行到当前队列的该进程时,仅分配上次还未完成的时间片,不再分配该队列对应的完整时间片。
    
    说明:在此我模拟了三级反馈队列,代码可以模拟多级,只需修改QueueNum即可,
    而且,本代码为非抢占式的调度算法实现。
    

    源代码:

    #include<bits/stdc++.h>
    #include<windows.h>
    using namespace std;
    struct PCB
    {
    	int pid;//进程号
    	char pname;//进程名
    	double priority;//优先级
    	int arrive;//到达时间
    	int service;//服务时间
    	int service_time;
    	int start;//开始时间
    	int end;//结束时间
    	int turnover;//周转时间
    	double author_turnover;//带权周转时间
    } pcb[5];
    
    int time_rr;//时间片
    
    double fcfs_author,fcfs_turnover,sjf_author,sjf_turnover,hrrn_author,hrrn_turnover,rr_author,rr_turnover,mfq_aythor,mfq;
    vector<PCB> fcfs;
    vector<PCB> sjf;
    vector<PCB> hrrn;
    vector<PCB> rr;
    vector<PCB> result;
    
    int cmp(PCB a,PCB b)//fcfs
    {
    	return a.arrive<b.arrive;
    }
    
    int cmp1(PCB a,PCB b)//sjf  排序,按service升序排序,如果service相等,则按arrive升序排序
    {
    	return (a.service<b.service)||(a.service==b.service&&a.arrive<b.arrive);
    }
    
    int cmp2(PCB p1, PCB p2) //hrrn
    {
    	return (p1.priority > p2.priority) || (p1.priority==p2.priority && p1.arrive<p2.arrive);
    }
    
    void Compare()//打印算法对比
    {
    	cout<<"先来先服务调度算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<fcfs.size(); i++)
    	{
    		cout<<"\t"<<fcfs[i].pname<<"\t\t"<<fcfs[i].arrive<<"\t\t"<<fcfs[i].service<<"\t\t"<<fcfs[i].end<<"\t\t"<<fcfs[i].turnover<<"\t\t";
    		printf("%.2lf\n",fcfs[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",fcfs_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",fcfs_author);
    
    	cout<<endl;
    	cout<<endl;
    
    	cout<<"短作业优先算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<sjf.size(); i++)
    	{
    		cout<<"\t"<<sjf[i].pname<<"\t\t"<<sjf[i].arrive<<"\t\t"<<sjf[i].service<<"\t\t"<<sjf[i].end<<"\t\t"<<sjf[i].turnover<<"\t\t";
    		printf("%.2lf\n",sjf[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",sjf_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",sjf_author);
    
    	cout<<endl;
    	cout<<endl;
    
    	cout<<"高响应比优先算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<hrrn.size(); i++)
    	{
    		cout<<"\t"<<hrrn[i].pname<<"\t\t"<<hrrn[i].arrive<<"\t\t"<<hrrn[i].service<<"\t\t"<<hrrn[i].end<<"\t\t"<<hrrn[i].turnover<<"\t\t";
    		printf("%.2lf\n",hrrn[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",hrrn_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",hrrn_author);
    
    	cout<<endl;
    	cout<<endl;
    
    	cout<<"时间片轮转调度算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<rr.size(); i++)
    	{
    		cout<<"\t"<<rr[i].pname<<"\t\t"<<rr[i].arrive<<"\t\t"<<rr[i].service_time<<"\t\t"<<rr[i].end<<"\t\t"<<rr[i].turnover<<"\t\t";
    		printf("%.2lf\n",rr[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",rr_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",rr_author);
    	
    	cout<<endl;
    	cout<<endl;
    
    	cout<<"多级反馈队列调度算法(使用了3级队列模拟)!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<result.size(); i++)
    	{
    		cout<<"\t"<<result[i].pname<<"\t\t"<<result[i].arrive<<"\t\t"<<result[i].service_time<<"\t\t"<<result[i].end<<"\t\t"<<result[i].turnover<<"\t\t";
    		printf("%.2lf\n",result[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",mfq);
    	printf("\t平均带权周转时间:%.2lf\n",mfq_aythor);
    
    	system("pause");
    	system("cls");
    }
    
    void print()
    {
    	system("cls");
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	system("pause");
    	system("cls");
    }
    
    void RR()//时间片轮转算法
    {
    	system("cls");
    	cout<<"时间片轮转调度算法!"<<endl;
    	cout<<endl;
    	cout<<"请输入时间片长度:";
    	cin>>time_rr;
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	int j=0,finish=0;
    	sort(pcb,pcb+5,cmp);
    	queue<PCB> q;
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	while(!q.empty()||j<5)
    	{
    		if(q.empty())
    		{
    			finish=pcb[j].arrive;
    			q.push(pcb[j++]);
    		}
    		if(q.front().service<=time_rr)
    		{
    			finish+=q.front().service;
    			while(j<5&&pcb[j].arrive<=finish)
    				q.push(pcb[j++]);
    			q.front().end=finish;
    			q.front().turnover=q.front().end-q.front().arrive;
    			q.front().author_turnover = double(q.front().turnover)/q.front().service_time;//带权周转时间=周转时间/服务时间
    			sum_turnover+=q.front().turnover;
    			sum_author_turnover+=q.front().author_turnover;
    			rr.push_back(q.front());
    			q.pop();
    		}
    		else
    		{
    			finish+=time_rr;
    			while(j<5&&pcb[j].arrive<=finish)
    				q.push(pcb[j++]);
    			q.front().service-=time_rr;
    			q.push(q.front());
    			q.pop();
    		}
    	}
    
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<rr[i].pname<<"\t\t"<<rr[i].arrive<<"\t\t"<<rr[i].service_time<<"\t\t"<<rr[i].end<<"\t\t"<<rr[i].turnover<<"\t\t";
    		printf("%.2lf\n",rr[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	rr_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	rr_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    void FCFS()   //先来先服务
    {
    
    	system("cls");
    	cout<<"先来先服务调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	int finish = 0;//当前时间,初始化为0
    	sort(pcb,pcb+5,cmp);
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	for(int i=0; i<5; i++)
    	{
    		if(pcb[i].arrive>finish)
    			pcb[i].end = pcb[i].arrive+pcb[i].service;
    		else
    			pcb[i].end = pcb[i].service+finish;
    		finish = pcb[i].end;
    		pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		fcfs.push_back(pcb[i]);
    	}
    
    	//过程
    	int cpu = 0;
    	int f[5] = {0};//初始化为0,代表不占用
    	while(1)
    	{
    		if(cpu==pcb[4].end)
    		{
    			cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
    			break;
    		}
    		for(int i=0; i<5; i++)
    		{
    			if(pcb[i].arrive==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
    			}
    		}
    		for(int i=0; i<5; i++)
    		{
    			if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
    			{
    				f[i]=1;//占用cpu
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    				Sleep(pcb[i].service*100);
    			}
    			if(pcb[i].end==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    				f[i]=0;//解除占用cpu
    			}
    		}
    		cpu++;
    	}
    
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
    		printf("%.2lf\n",pcb[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	fcfs_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	fcfs_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    
    
    void SJF()
    {
    	system("cls");
    	cout<<"短作业优先调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    
    	int i,j=0,finish=0;//j为当前就绪队列的末尾指针
    	sort(pcb,pcb+5,cmp);//排序
    
    //	for(int i=0;i<5;i++)
    //		cout<<pcb[i].pname; 测试排序是否正确
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	for(int i=0; i<5; i++)
    	{
    		while(j<5&&pcb[j].arrive<=finish)//当有新的进程的进入时间小于当前时间,就加入就绪队列
    			j++;
    		sort(pcb+i,pcb+j,cmp1);
    		if(pcb[i].arrive>finish)
    			pcb[i].end = pcb[i].arrive+pcb[i].service;
    		else
    			pcb[i].end = pcb[i].service+finish;
    		finish = pcb[i].end;
    		pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		sjf.push_back(pcb[i]);
    	}
    
    	//过程
    	int cpu = 0;
    	int f[5] = {0};//初始化为0,代表不占用
    	while(1)
    	{
    		if(cpu==pcb[4].end)
    		{
    			cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
    			break;
    		}
    		for(int i=0; i<5; i++)
    		{
    			if(pcb[i].arrive==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
    			}
    		}
    		for(int i=0; i<5; i++)
    		{
    			if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
    			{
    				f[i]=1;//占用cpu
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    				Sleep(pcb[i].service*100);
    			}
    			if(pcb[i].end==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    				f[i]=0;//解除占用cpu
    			}
    		}
    		cpu++;
    	}
    
    
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
    		printf("%.2lf\n",pcb[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	sjf_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	sjf_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    void init()
    {
    	cout<<endl;
    //	for(int i=0;i<5;i++)
    //	{
    //		pcb[i].pid = i;
    //		cout<<"进程:"<<i<<endl;
    //		cout<<"进程名:";
    //		cin>>pcb[i].pname;
    //		cout<<"到达时间:";
    //		cin>>pcb[i].arrive;
    //		cout<<"服务时间:";
    //		cin>>pcb[i].service;
    //		cout<<endl;
    //	}
    	pcb[0].pname='A';
    	pcb[0].arrive=0;
    	pcb[0].service=3;
    	pcb[0].service_time=3;
    
    	pcb[1].pname='B';
    	pcb[1].arrive=2;
    	pcb[1].service=6;
    	pcb[1].service_time=6;
    
    	pcb[2].pname='C';
    	pcb[2].arrive=4;
    	pcb[2].service=4;
    	pcb[2].service_time=4;
    
    	pcb[3].pname='D';
    	pcb[3].arrive=6;
    	pcb[3].service=5;
    	pcb[3].service_time=5;
    
    	pcb[4].pname='E';
    	pcb[4].arrive=8;
    	pcb[4].service=2;
    	pcb[4].service_time=2;
    	system("cls");
    }
    
    void menu()
    {
    	cout<<endl;
    	cout<<endl;
    	cout<<"\t   进程调度模拟程序"<<endl;
    	cout<<endl;
    	cout<<"\t1. 输入作业情况"<<endl;
    	cout<<endl;
    	cout<<"\t2. 显示作业情况"<<endl;
    	cout<<endl;
    	cout<<"\t3. 先来先服务算法"<<endl;
    	cout<<endl;
    	cout<<"\t4. 短作业优先算法"<<endl;
    	cout<<endl;
    	cout<<"\t5. 高响应比优先算法"<<endl;
    	cout<<endl;
    	cout<<"\t6. 时间片轮转算法"<<endl;
    	cout<<endl;
    	cout<<"\t7. 多级反馈队列调度"<<endl;
    	cout<<endl;
    	cout<<"\t8. 算法结果对比"<<endl;
    	cout<<endl;
    	cout<<"\t0. 退出"<<endl;
    	cout<<endl;
    	cout<<"请输入选择:";
    }
    
    void HRRN()
    {
    	system("cls");
    	cout<<"高响应比调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	int j=0;
    	int finish=0;
    	sort(pcb, pcb+5, cmp);
    	for(int i = 0; i < 5; i++)
    	{
    		while(j<5 && pcb[j].arrive <= finish)
    			j++;
    		for(int k = i; k < j; k++)
    			pcb[k].priority = (finish-pcb[k].arrive+pcb[k].service) / pcb[k].service;
    		sort(pcb+i, pcb+j, cmp2);
    
    		if(pcb[i].arrive > finish)
    			pcb[i].end = pcb[i].arrive + pcb[i].service;
    		else
    			pcb[i].end = finish + pcb[i].service;
    		pcb[i].turnover = pcb[i].end - pcb[i].arrive;
    		finish = pcb[i].end;
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		hrrn.push_back(pcb[i]);
    	}
    
    
    	//过程
    	int cpu = 0;
    	int f[5] = {0};//初始化为0,代表不占用
    	while(1)
    	{
    		if(cpu==pcb[4].end)
    		{
    			cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
    			break;
    		}
    		for(int i=0; i<5; i++)
    		{
    			if(pcb[i].arrive==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
    			}
    		}
    		for(int i=0; i<5; i++)
    		{
    			if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
    			{
    				f[i]=1;//占用cpu
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    				Sleep(pcb[i].service*100);
    			}
    			if(pcb[i].end==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    				f[i]=0;//解除占用cpu
    			}
    		}
    		cpu++;
    	}
    
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
    		printf("%.2lf\n",pcb[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	hrrn_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	hrrn_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    int times[3]= {1,2,4};
    
    void MFQ()//多级反馈队列调度
    {
    	system("cls");
    	cout<<"多级反馈队列调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	sort(pcb,pcb+5,cmp);//按到达时间排序
    	int finish=0,j=0;
    	finish = pcb[j].arrive;					//第一个作业开始时间
    	const int QueueNum = 3;
    	queue<PCB> Ready[QueueNum];		//设置3个就绪队列
    	Ready[0].push(pcb[j++]);
    	for(int i=0; i<5; i++)
    	{
    		pcb[i].end=0;//运行了多少时间 
    	}
    	int cnt=0;
    	while (1)
    	{
    		//这段是为了防止前面的进程运行完了,后面的进程还没到,造成死循环
    		bool flag = false;
    		for (int i = 0; i < QueueNum; ++i)
    		{
    			if (!Ready[i].empty())
    			{
    				flag = true;
    				break;
    			}
    		}
    		if(!flag)
    		{
    			Ready[0].push(pcb[j++]);
    //			finish = Ready[0].front().arrive;
    		}
    
    		for (int i = 0; i < QueueNum; i++)
    		{
    //			int times = timeslice * (i + 1);		//下一个队列的时间片大小是上一个的2倍
    			if (i == QueueNum - 1)		//是最后一个队列
    			{
    				while (!Ready[i].empty())
    				{
    					if(j<5 &&pcb[j].arrive<=finish)	//有新作业到达,加入就绪队列,转到第一队列
    					{
    						Ready[0].push(pcb[j++]);
    						i = 0;
    						break;
    					}
    					if (Ready[i].front().service>times[i]+Ready[i].front().end)		//时间片用完没运行完,加入队尾
    					{
    						
    						Ready[i].front().end += times[i];
    						Ready[i].push(Ready[i].front());
    						Ready[i].pop();
    						finish += times[i]; 
    					}
    					else		//此作业运行完
    					{
    						finish += Ready[i].front().service-Ready[i].front().end;
    						Ready[i].front().end = finish;
    						Ready[i].front().turnover = Ready[i].front().end - Ready[i].front().arrive;
    						Ready[i].front().author_turnover = (double)Ready[i].front().turnover / Ready[i].front().service_time;
    						sum_turnover+=Ready[i].front().turnover;
    						sum_author_turnover+=Ready[i].front().author_turnover;
    
    						//从就绪队列中移除作业
    						result.push_back(Ready[i].front());
    						Ready[i].pop();
    						cnt++;
    					}
    				}
    			}
    			else
    			{
    				while (!Ready[i].empty())		//队列不空
    				{
    					if(j<5 && pcb[j].arrive<=finish)	//有新作业到达,加入就绪队列
    					{
    						Ready[0].push(pcb[j++]);
    						i = 0;//转到第一队列
    						continue;
    					}
    
    					if (Ready[i].front().service>times[i]+Ready[i].front().end)		//时间片用完没运行完,加入下一队列队尾
    					{
    						Ready[i].front().end += times[i];
    						Ready[i + 1].push(Ready[i].front());
    						Ready[i].pop();
    						finish += times[i];//更新当前时间
    					}
    					else		//此作业运行完
    					{
    						finish += (Ready[i].front().service-Ready[i].front().end);
    						Ready[i].front().end = finish;
    						Ready[i].front().turnover = Ready[i].front().end - Ready[i].front().arrive;
    						Ready[i].front().author_turnover = (double)Ready[i].front().turnover / Ready[i].front().service_time;
    						sum_turnover+=Ready[i].front().turnover;
    						sum_author_turnover+=Ready[i].front().author_turnover;
    
    						//从就绪队列中移除作业
    						result.push_back(Ready[i].front());//保存结果
    						Ready[i].pop();
    						cnt++;
    					}
    				}
    			}
    		}
    		if(cnt==5)
    			break;
    	}
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<result[i].pname<<"\t\t"<<result[i].arrive<<"\t\t"<<result[i].service_time<<"\t\t"<<result[i].end<<"\t\t"<<result[i].turnover<<"\t\t";
    		printf("%.2lf\n",result[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	mfq=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	mfq_aythor=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    int main()
    {
    	int flag=1;
    	while(1)
    	{
    		menu();
    		int sel;
    		cin>>sel;
    		switch(sel)
    		{
    			case 1:
    				init();
    				break;
    			case 2:
    				print();
    				break;
    			case 3:
    				FCFS();
    				break;
    			case 4:
    				SJF();
    				break;
    			case 5:
    				HRRN();
    				break;
    			case 6:
    				RR();
    				break;
    			case 7:
    				MFQ();
    				break;
    			case 8:
    				Compare();
    				break;
    			case 0:
    				exit(0);
    		}
    	}
    	return 0;
    }
    
    

    运行效果:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  •  分配给进程A时间片”使用完时,CPU会进行上下文切换以便运行其他进程,比如进程B,这里所谓“上下文切换”,主要就是在操作那个“进程表”,其将进程A相关信息(上下文)保存到其对应的进程表项中, 与之...
  • 时间片轮转

    2016-04-20 11:24:10
    时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法,又称RR调度。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的...当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信
  • 当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号 来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新 的队首进程,同时也让它执行一个时间片。这样就可以...
  • linux中的进程控制

    2017-04-01 14:50:13
    linux中的进程控制 进程控制理论基础 程序是一组可执行的静态指令集,而进程(process)是...当进程的时间片用完时系统就利用调度程序切换到另一个进程去运行。因此实际上对于具体单个CPU的机器来说某一个时刻只能运行一
  • linux进程3.进程的三态

    2020-10-24 11:32:56
    例如,当一个进程由于时间片用完而进入就绪状态,排入低优先级队列;当进程由I/O操作完成而进入就绪状态,排入高优先级队列。 执行状态:当一个进程在处理机上运行,则称该进程处于运行状态。 阻塞状态:也...
  • 时间片轮转算法

    千次阅读 2018-11-12 21:39:41
    时间片轮转算法:主要用于分系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入...当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该进程的运行,把它放入就绪队列的末尾;然...
  • 时间片轮转法

    千次阅读 2018-12-10 20:33:27
    时间片轮转法(Round-Robin,RR)主要用于分系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成...当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该进程的运行...
  • 进程的三种状态

    2020-03-26 12:17:21
    进程有三个状态:就绪状态,执行状态,阻塞状态。 运行——>就绪:1,主要是进程占用CPU的时间过长,而...运行:运行的进程的时间片用完,调度就转到就绪队列中选择合适的进程分配CPU 运行——>阻塞:正在执...
  • Linux中的进程管理

    2021-01-20 10:27:01
    1.进程定义 进程: 程序是静态代码文件 进程是程序执行时的形态 进程是程序一个副本 进程是有生命周期,共三个时期(准备期 执行期 终止期) ...#S ##可唤醒状态 时间片用完 #D ##不可唤醒状态 缺少某种资
  • 时间片轮转调度算法

    千次阅读 2012-03-27 15:29:24
    当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪...
  • 本文介绍一下多进程执行过程,一个进程需要停下来等待某个条件或者cpu给它分配的时间片用完时需要切换给别的进程,在切换时首先会产生一个中断,然后cpu会执行相应的中断处理操作,比如一个重要的操作就是保护...
  • 抢占进程调度原则

    千次阅读 2012-05-16 09:48:25
    (1)时间片原则:各进程按系统分配给一个时间片运行,时间片用完或由于该进程等待某事件发生而被阻塞,系统就停止该进程的执行而重新进行调度。  (2)优先级原则:每个进程均赋于一个调度优先级,通常...
  • 当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。这样就可以...
  • linux进程进程控制

    千次阅读 2015-09-07 11:33:57
    Linux进程控制  程序是一组可执行的静态指令集,而进程(process)是一个...当进程的时间片用完时系统就利用调度程序切换到另一个进程去运行。因此实际上对于具体单个CPU的机器来说某一个时刻只能运行一个进
  • 如果时间片用完或被强占,进入就绪态;资源得不到满足,进入睡眠态(深度睡眠或浅度睡眠),比如一个网络程序,在等对方发包,此时不能占着CPU,进入睡眠态,包发过来进程被唤醒,进入就绪态;如果被暂停,...
  • RT-thread 时间片轮转法

    千次阅读 2018-09-22 11:05:07
    时间片轮转 主要用于分系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先...当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该进程的运行,把它放入就绪队列的末尾;然后...
  • 操作系统-时间片轮转调度算法

    千次阅读 2020-04-07 18:42:46
    基本概念 时间片轮转法(Round-Robin,RR)主要用于分系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成...当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该...
  • 就绪:1,主要是进程占用CPU的时间过长,时间片用完; 2,在采用抢先式优先级调度算法的系统中,有更高优先级的进程要运行,该进程就被迫让出CPU,该进程便由执行状态转变为就绪状态。 ...

空空如也

空空如也

1 2 3 4 5
收藏数 84
精华内容 33
关键字:

当进程执行的时间片用完时