精华内容
下载资源
问答
  • FCFS算法
    2022-05-10 17:46:16

    #include<iostream>
    #include<algorithm>
    #include<vector>
    #define num 4
    #define col 3
    using namespace std;
    int data[num][col] = {{1,0,120},
                          {2,50,50},
                          {3,60,10},
                          {4,110,20}
    };

    void sort_fcfs(){
        for(int i=0; i<num-1; i++)
            for(int j=i+1; j<num; j++){
                if(data[i][1] > data[j][1])
                   swap(data[i],data[j]);
            }
    }

    double sum_array(double a[]){
        int i = 0;
        double sumf = 0;
        while(i<num){
            sumf = sumf + a[i];
            i++;
        }
        return sumf/num ;
    }

    void Fcfs(){
        sort_fcfs();
        int finishtime[num];
        double runovertime[num];//周转时间 
        double dqzztime[num];//带权周转时间 
        
        for(int i=0; i<num; i++){
            if(i == 0){
                finishtime[i] = data[i][1] + data[i][2];
            }
            else{
                finishtime[i] = finishtime[i-1] + data[i][2];
            }
        }
        
        for(int i=0; i<num; i++){
            runovertime[i] = finishtime[i] - data[i][1];
            dqzztime[i] = runovertime[i] / data[i][2]; 
        }
        printf("FCFS调度算法结果是:\n");
        printf("作业名\t完成时间\t周转时间\t带权周转时间\n");
            for(int i=0; i<num; i++){
                printf("%d\t%d\t        %.1lf\t        %.1lf\n",data[i][0],finishtime[i],runovertime[i],dqzztime[i]);
            }
        printf("平均周转时间:%.1lf\n",sum_array(runovertime));
        printf("平均带权周转时间:%.3lf\n",sum_array(dqzztime));
            
    }
    int main(){
        printf("-------------------------------\n");
        printf("作业名   到达时间   服务时间\n");
        for(int i=0; i<num; i++){
            for(int j=0; j<col; j++){
                printf("%d           ",data[i][j]);
            }
            printf("\n");
        }
        printf("-------------------------------\n");
        Fcfs();
        return 0;
    }

    更多相关内容
  • First-Come, First-Served 按照作业提交或进程变为就绪状态的先后次序,分派CPU;当前作业或进程占用CPU,直到执行完成或阻塞才让出CPU(非抢占方式) 优点:先到的进程先服务,比较利于长作业,利于CPU繁忙的作业 ...
  • 编制一段程序,对所输入的若干作业,按FCFS算法模拟调度,观察、记录并分析调度的输出结果情况
  • 用java简单实现fcfs算法和sjf算法
  • 磁盘调度算法FCFS算法 实验内容: 磁盘访问序列和磁头起始位置(自己输入数据),采用SSTF磁盘调度算法,求平均寻道长度。 实验目的: 本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度...

    实验题目:

    磁盘调度算法FCFS算法

    实验内容:

    磁盘访问序列和磁头起始位置(自己输入数据),采用SSTF磁盘调度算法,求平均寻道长度。

    实验目的:

    本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解

    实验原理:问题分析及算法设计(流程图)

    在这里插入图片描述

    实验源代码:

    #include <stdio.h>
    #include <math.h>
    #include <limits.h>
    void FCFS(int m,int n,int track_number[]){
    	int fcfs_seq[100][2];
    	int pre_track_number = m;
    	double ave_seek = 0;
    	for(int i = 0; i < n; i++){
    		fcfs_seq[i][0] = track_number[i];
    		fcfs_seq[i][1] = abs(pre_track_number - track_number[i]);
    		pre_track_number = track_number[i];
    		ave_seek += fcfs_seq[i][1];
    	}
    	ave_seek /= n;
    	printf("\nFCFS寻道序列:\n"); 
    	for(int i = 0; i < n; i++){
    		printf("%d %d\n",fcfs_seq[i][0],fcfs_seq[i][1]);
    	} 
    	printf("FCFS平均寻道:%0.2lf\n", ave_seek);
    } 
    
    
    int main(){
    	int m;//磁道针起始位置
    	int n;//寻道的磁道数
    	int  track_number[100];//
    	printf("输入磁道针起始位置:"); 
    	scanf("%d",&m);
    	printf("输入寻道的磁道数:");
    	scanf("%d",&n);
    	for(int i = 0; i < n; i++){
    		printf("输入第%d个磁道号的位置:",i+1);
    		scanf("%d",&track_number[i]);
    	} 
    	FCFS(m,n,track_number);
    }
    

    实验结果:(截图)

    在这里插入图片描述

    实验总结:(心得体会)

    过本次实验的具体操作,了解了磁盘调度的FCFS算法、SSTF算法、SCAN算法、CSCAN算法的具体代码和实现过程,掌握了不同的调度算法的各自特点,并与具体的理论知识相比较与验证,对掌握的理论知识有了更准确的理解。

    展开全文
  • FCFS算法和SJF算法

    千次阅读 2020-12-10 10:21:55
    FCFS算法和SJF算法(非抢占式) 此处主要说一下SJF算法,FCFS算法仅仅按到达时间选择或者排序即可 SJF算法设计思路: 我看了看大多数人写的SJF算法,有些用的是排序算法,虽然能做出来,但是在CPU调用期间,CPU并不...

    FCFS算法和SJF算法(非抢占式)

    此处主要说一下SJF算法,FCFS算法仅仅按到达时间选择或者排序即可
    在这里插入图片描述
    SJF算法设计思路
    我看了看大多数人写的SJF算法,有些用的是排序算法,虽然能做出来,但是在CPU调用期间,CPU并不知道接下来一段时间,要运行进程的数量,并且如果选用排序算法,我们不能衡量CPU资源是否是空闲的,换句话说,此处的排序算法是一种静态算法,本设计思路没有用排序算法,而是选用缓冲区,所以我在此处设置一个缓冲区,如果缓冲区中没有进程,那么CPU资源就是空闲的,说明没有进程调用,如果缓冲区有进程,那么选择其中服务时间最小的一个,在执行完毕后清除该进程在缓冲区的信息,同时观察在该进程结束时,有没有新的进程来临,如果有,进入缓冲区,继续调用,直至缓冲区中没有数据以及所有进程调用完毕。
    执行流程:

    ①在CPU资源空闲时,扫描所有,选取arrivaltime最小的进程,如果有两或者两以上个相同的arrivaltime最小,那么取其中servertime最小的一个,即是第一个调用的进程,与其相同的到达时间的进程将进入缓冲区,将进入缓冲区的进程的Isfinisntime_SIF置为1。

    ②该进程执行完毕后,清除其在缓冲区的进程信息,并进行检索,在调用的进程的starttime+servertime=finishtime完成时间内,如果有新来的进程也会进入缓冲区,也就是新来的进程的arrivaltime<被调用进程的finishtime,将进入缓冲区的进程的Isfinisntime_SIF置为1。

    ③之后选择缓冲区所有进程服务时间最小的的一个,将其调用执行,之后,重复步骤②,直至缓冲区没有进程信息,但是此处并不代表算法的结束,毕竟,有的进程可能来临时间极慢例如表中C,D的到达时间为20,在B执行完后,CPU资源是空闲的,所以结束的标志是缓冲区没有信息并且所有进程的Isfinisntime_SIF=1)那么判断结束标志,如果满足,算法结束;如果不满足,重复调用①②③,直至满足算法结束条件。
    在这里插入图片描述

    PS:数据结构用的顺序表,懒的写了,直接套用之前的,注释写的可能乱
    下面是代码:

    
    #include <iostream>  //冗余???
    #include <stdio.h>
    #include <stdlib.h>
    #include <queue> //直接调已封装的队列
    using namespace std;
    #define OK 1
    #define ERROR -1
    #define MaxNum 100 //即是最大允许100个进程,编号最大也为100
    #define OVERFLOW -3
    typedef struct
    {
    int  ProcessId ;//进程id
    int  ArrivalTime;  //到达时间
    int  ServiceTime;  //服务时间
    int  FinishTime;   //完成时间
    int  WholeTime;    //周转时间
    int  StratTime;//开始执行时间
    int  Buffer_Location;
    double  WeightWholeTime;      //带权周转时间
    bool isFinished_FCFS;//标志位,是否已经完成
    bool isFinished_SJF;//标志位,是否已经完成
    }PCB;
    typedef struct
    {
    	PCB *elem;
    	int n;//进程数目,也是顺序表的长度
    }Sqlist; //顺序表数据
    typedef struct //缓冲池存有部分进程的数据
    {
       int buffer_server;//该进程的服务时间 
       int buffer_location;//该进程在L表中的位置
    }Buffer;//
    int waiting=0;//等待时间
    int count=0;//计数,由此查看缓冲区是否为空
    double AveWholeTime=0;  //平均周转时间=作业周转时间/作业个数
    double AveWeightWholeTime=0; //平均带权周转时间=带权周转总时间/作业个数
    Buffer B[MaxNum];
    int flag_count=0;
    int k=0;
    void  SJF_Buffer(Sqlist &L);//缓冲区函数
    void Elect(Sqlist &L);
    void Display(Sqlist &L);
    void SJF(Sqlist &L);//短作业优先算法
    void FCFS(Sqlist &L);//先来先服务算法
    
     int InitList_sq(Sqlist &L)   //初始化顺序表
    {
    	L.elem=new PCB[MaxNum];//分配内存,数组指针
    	if(!L.elem)  //首地址为空时,l.elem=0,!0=1.即执行
    	{
    		printf("allocation failed");
    		exit(OVERFLOW);//失败时函数结束
    	}
    	L.n=0;
    	return ERROR;
    }
    void Create_Sq(Sqlist &L) //依次从键盘读入数据,建立顺序表;
    {
      cout<<" Please enter the number of processes:"<<endl;
      cin>>L.n;
      cout<<"Please enter the arrivaltime of each process separately:"<<endl;
      for (int i =0; i <L.n; i++)
      {
        L.elem[i].ProcessId=i+1;
        cin>>L.elem[i].ArrivalTime;
        L.elem[i].isFinished_FCFS=0;
        L.elem[i].isFinished_SJF=0;
         }
        cout<<"Please input the servicetime of each process separately"<<endl;
       for (int i =0; i <L.n; i++)
       {
       cin>>L.elem[i].ServiceTime;  /* code */
       } 
    }
       int main()
    	 {	   
             Sqlist L;
             InitList_sq(L);
             Create_Sq(L);
             Display(L); 
             Elect(L); 
             system("pause");
             return 0 ;
    	 }
         void Elect(Sqlist &L)
        {
            int choice,flag=1;
            cout<<"Please select the algorithm: 1-FCFS     2-SJF"<<endl;
            cin>>choice;
            while(flag)
            {
              if(choice==1)
              {
                 FCFS(L);//先来先服务算法
                 flag=0;  
              }
              else if(choice==2)
              {
                 SJF(L);//短作业优先算法  
                 flag=0;  
              }
              else
               cout<<"Your choice input error, please re-enter!"<<endl; /* code */                  
            }
        }     
           void Display(Sqlist &L)
           {
            cout<<"********************************************"<<endl;
            cout<<"The number of processes input by user  is n="<<L.n<<endl;
            cout<<"The arrivaltime entered by the user is as follows:"<<endl;
             for (int i =0; i <L.n; i++)
             {          
               cout<<L.elem[i].ArrivalTime<<" ";
             }
             cout<<endl;
             cout<<"The servicetime of the user is as follows:"<<endl;
             for (int i =0; i <L.n; i++)
             {
               cout<<L.elem[i].ServiceTime<<" ";  /* code */
             } 
             cout<<endl;
             cout<<"********************************************"<<endl;
           }
          void FCFS(Sqlist &L)//先来先服务算法 
    	  {
             //排序算法+选择算法实现FCFS
            int arr[L.n]={0};
            for(int i = 0; i < L.n; i++ )
             {
              arr[i]=L.elem[i].ArrivalTime;
             }
    	      for (int i = 0; i <L.n; i++)//冒泡排序
    	       {
    	       	for (int j = 0; j <L.n -  i - 1; j++)
    	      	{
    		       	if (arr[j] > arr[j + 1])
    		        	{
    				      int temp;
    				       temp = arr[j + 1];
    				      arr[j + 1] = arr[j];
    				      arr[j] = temp;
    			        }
    		      }
           	 }
            cout<<" process informantion :"<<endl;
            cout<<"ProcessID"<<"\t" <<"arrivaltime"<<"\t"<<"servertime "<<"\t" 
            <<"FinishTime"<<"\t" <<"WholeTime"<<"\t" <<"WeightWholeTime"<<endl;
             int  j=0,temp=10;
            for(int i = 0; i < L.n; i++)          
            {
                for (j = 0; i <  L.n; j++)//取出最小的达到时间,即是最先
                {
                  if(arr[i]==L.elem[j].ArrivalTime&&L.elem[j].isFinished_FCFS!=1)
                   break;
                }
                if(L.elem[j].ArrivalTime<temp&&i!=0)//判断此进程到达时cpu资源是否空闲
                   L.elem[j].StratTime=temp;
                else
                   L.elem[j].StratTime= L.elem[j].ArrivalTime;//说明不空闲,立即执行
                L.elem[j].isFinished_FCFS=1;//该进程已经访问完成         
                L.elem[j].FinishTime=L.elem[j].StratTime+L.elem[j].ServiceTime;
                L.elem[j].WholeTime=L.elem[j].StratTime+L.elem[j].ServiceTime-L.elem[j].ArrivalTime;
                L.elem[j].WeightWholeTime=(L.elem[j].StratTime+L.elem[j].ServiceTime-L.elem[j].ArrivalTime)*1.0/L.elem[j].ServiceTime;
                temp=L.elem[j].StratTime+L.elem[j].ServiceTime;//临时存放进程的完成时间,作为下一个进程的开始时间  
            }
            for( j = 0; j < L.n; j++)
             {
                cout<<L.elem[j].ProcessId<<"\t\t" <<L.elem[j].ArrivalTime<<"\t\t"<<L.elem[j].ServiceTime<<"\t\t" << 
                L.elem[j].FinishTime<<"\t\t" << L.elem[j].FinishTime-L.elem[j].ArrivalTime
                <<"\t\t" <<(L.elem[j].FinishTime-L.elem[j].ArrivalTime)*1.0/L.elem[j].ServiceTime<<endl; 
                AveWholeTime=L.elem[j].WholeTime+AveWholeTime;
                AveWeightWholeTime=L.elem[j].WeightWholeTime+AveWeightWholeTime;
             } 
             cout<<" The AverageWholeTime is "<<AveWholeTime*1.0/L.n<<endl;
             cout<<" The AverageWeightWholeTime is "<<AveWeightWholeTime*1.0/L.n<<endl;
    	  }
    	  void SJF(Sqlist &L)//短作业优先算法
    	  {         
              int i,j,s;
              for ( i = 0; i < L.n; i++)//初始化缓冲区
              {
                 B[i].buffer_location=MaxNum;
                 B[i].buffer_server=MaxNum;
              } 
              int flag_ar=0;
              int minat=MaxNum,location=MaxNum,minser=MaxNum;
             while(flag_count!=L.n)
             {
                flag_count=0;
                for ( i = 0; i < L.n; i++)
                {
                  if (B[i].buffer_server== MaxNum)//说明缓冲区此时没有数据,CPU资源空闲,
                  {
                      count=1+count;
                  }
                }
              if(count==L.n) //说明缓冲区此时没有数据,CPU资源空闲,
              {
                     for ( i = 0; i < L.n; i++)
                     {
                        if(L.elem[i].ArrivalTime<minat && L.elem[i].isFinished_SJF!=1)
                        {
                            minat=L.elem[i].ArrivalTime;
                            location=i;
                            minser=L.elem[i].ServiceTime;
                        }
                     }//找到最小的到达时间
                     L.elem[location].isFinished_SJF=1;
                     L.elem[location].Buffer_Location=k;
                     B[k].buffer_location=location;
                     B[k].buffer_server=minser;
                     k=k+1;//找到最小的到达时间,并让其进入缓冲区
                    for ( j = 0; j < L.n; j++)
                     {
                        if(L.elem[j].ArrivalTime==minat && L.elem[j].isFinished_SJF!=1) 
                        {
                            flag_ar=1;//标志位为1,说明另一个进程也有相同的到达时间
                            minat=L.elem[j].ArrivalTime;
                            location=j;
                            minser=L.elem[j].ServiceTime;
                            L.elem[location].isFinished_SJF=1;
                            B[k].buffer_location=location;
                            B[k].buffer_server=minser;
                            L.elem[j].Buffer_Location=k;
                            k=k+1;//说明另一个进程也有相同的到达时间,并让其进入缓冲区
                        }
                     }//说明另一个进程也有相同的到达时间
                 count=0; 
                 minat=MaxNum,location=MaxNum,minser=MaxNum;
               }
              else
              {        location=MaxNum,minser=MaxNum;//说明缓冲区此时有数据,CPU资源不空闲,
                     for ( i = 0; i < k; i++)
                     {
                        if(B[i].buffer_server<minser)
                        {
                            location=B[i].buffer_location;
                            minser=B[i].buffer_server;
                        }
                     }//找到最小的服务时间service并进行调用
                     if(L.elem[location].ArrivalTime>=waiting)
                        L.elem[location].StratTime=L.elem[location].ArrivalTime;// 进程的开始时间????
                     else
                        L.elem[location].StratTime=waiting;            
                     L.elem[location].FinishTime=L.elem[location].StratTime+L.elem[location].ServiceTime;
                     L.elem[location].WholeTime=L.elem[location].FinishTime-L.elem[location].ArrivalTime;
                     L.elem[location].WeightWholeTime=L.elem[location].WholeTime/L.elem[location].ServiceTime;                
                     B[L.elem[location].Buffer_Location].buffer_server=MaxNum;//退出缓冲区,清除其在缓冲区的数据
                     waiting=L.elem[location].FinishTime;//更新等待时间
                       for ( j = 0; j < L.n; j++)
                     {
                        if(L.elem[j].ArrivalTime<=waiting && L.elem[j].isFinished_SJF!=1)
                        {
                            L.elem[j].isFinished_SJF=1;
                            B[k].buffer_location=j;
                            B[k].buffer_server=L.elem[j].ServiceTime;
                             L.elem[j].Buffer_Location=k;
                            k=k+1;
                        }
                     }//在此进程的完成时间内,有没有新的进程进入,有的话进入缓冲区 
                 count=0;                                 
               }//此对应else
               for (int h = 0; h < L.n; h++)
               {
                   if (L.elem[h].isFinished_SJF==1 && B[h].buffer_server==MaxNum)
                   {
                     flag_count=flag_count+1;
                   }               
               }              
          } 
            cout<<" process informantion :"<<endl;
            cout<<"ProcessID"<<"\t" <<"arrivaltime"<<"\t"<<"servertime "<<"\t" 
            <<"FinishTime"<<"\t" <<"WholeTime"<<"\t" <<"WeightWholeTime"<<endl;
           for( j = 0; j < L.n; j++)
             {
                cout<<L.elem[j].ProcessId<<"\t\t" <<L.elem[j].ArrivalTime<<"\t\t"<<L.elem[j].ServiceTime<<"\t\t" << 
                L.elem[j].FinishTime<<"\t\t" << L.elem[j].FinishTime-L.elem[j].ArrivalTime
                <<"\t\t" <<(L.elem[j].FinishTime-L.elem[j].ArrivalTime)*1.0/L.elem[j].ServiceTime<<endl; 
                AveWholeTime=L.elem[j].WholeTime+AveWholeTime;
                AveWeightWholeTime=L.elem[j].WeightWholeTime+AveWeightWholeTime;
             }
             cout<<" The AverageWholeTime is "<<AveWholeTime*1.0/L.n<<endl;
             cout<<" The AverageWeightWholeTime is "<<AveWeightWholeTime*1.0/L.n<<endl; 
          }
         
    

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

    展开全文
  • C语言FCFS算法

    2015-12-04 20:50:32
    先来先服务算法,使用C语言实现,深入了解进程调度
  • #include#define PNUMBER 5//进程个数#define SNUMBER 3//资源种类个数//资源的种类,三种char stype[SNUMBER]={‘A‘,‘B‘,‘C‘};//各种资源的总数量,a种资源总10,b种资源总5,c种资源总7int avalable[SNUMBER]...

    #include

    #define PNUMBER 5//进程个数

    #define SNUMBER 3//资源种类个数

    //资源的种类,三种

    char stype[SNUMBER]={‘A‘,‘B‘,‘C‘};//各种资源的总数量,a种资源总10,b种资源总5,c种资源总7

    int avalable[SNUMBER]={10,5,7};//每个进程对应的完成进程需要的各种类型的资源需求量,静态值

    int pmax[PNUMBER][SNUMBER]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//每个进程已经分配的资源情况,动态值

    int allocation[PNUMBER][SNUMBER]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};//每一个进程还需要的资源

    int pneed[PNUMBER][SNUMBER]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//临时的数组

    intrequest[SNUMBER];//当前正在分配资源的进程

    int pindex=0;//显示每一个进程对资源拥有的现状

    voidshowdate();//接受进程分配的请求

    voidaccepetRequest();//模拟分配

    void SimMllocation(intpindex);//回滚

    void rollback(intpindex);//安全性检查

    intcheckIsSafe();intmain()

    {//主逻辑

    int exit=0;//显示每一个进程现状

    showdate();do{//接受进程分配的请求

    accepetRequest();//模拟分配资源

    SimMllocation(pindex);//显示现在资源现状

    showdate();//检查是否存在安全序列,数据要保证至少一个进程能完成分配

    if(checkIsSafe()==0)

    {//当前进程不存在安全序列,当前进程数据回滚

    rollback(pindex);

    }

    printf("是否继续0/1\n");

    scanf("%d",&exit);

    }while(exit==1);return 0;

    }//显示每一个进程对资源拥有的现状

    voidshowdate()

    {int index=0;int index_=0;

    printf("当前资源情况.....\n");

    printf("资源类类型\t资源数量\n");for(index=0;index

    {

    printf("%c\t\t%d\n",stype[index],avalable[index]);

    }

    printf("\n\n每一个进程所需要资源的最大值.........\n\n");

    printf("进程编号\t资源类型A\t资源类型B\t资源类型C\n");for(index=0;index

    {

    printf("%d\t\t",index);for(index_=0;index_

    {

    printf("%d\t\t",pmax[index][index_]);

    }

    printf("\n");

    }

    printf("\n\n每一个进程所分配的情况......\n\n");

    printf("进程编号\t资源类型A\t资源类型B\t资源类型C\n");for(index=0;index

    {

    printf("%d\t\t",index);for(index_=0;index_

    {

    printf("%d\t\t",allocation[index][index_]);

    }

    printf("\n");

    }

    printf("\n\n每一个进程还需要的资源的情况......\n\n");

    printf("进程编号\t资源类型A\t资源类型\t资源类型C\n");for(index=0;index

    {

    printf("%d\t\t",index);for(index_=0;index_

    {

    printf("%d\t\t",pneed[index][index_]);

    }

    printf("\n");

    }

    printf("---------------------------------------------------------------------------------------------\n");

    }voidaccepetRequest()

    {int index=0;

    printf("请输入你要分配资源的进程编号(0~%d)\n",PNUMBER-1);//需要分配资源的进程

    scanf("%d",&pindex);//输入需要各种资源的具体数量

    for(index=0;index

    {

    printf("请输入%c类资源的数量\n",stype[index]);

    scanf("%d",&request[index]);//小于进程对资源的最大要求

    if(request[index]<=pmax[pindex][index]&&request[index]<=avalable[index])

    {

    index++;

    }

    }

    }//模拟分配

    void SimMllocation(intpindex)

    {int index=0;for(index=0;index

    {//总资源减少

    avalable[index]-=request[index];//当前进程已经分配的资源

    allocation[pindex][index]+=request[index];//还需要的资源

    pneed[pindex][index]-=request[index];

    }

    }//回滚

    void rollback(intpindex)

    {int index=0;for(index=0;index

    {

    avalable[index]+=request[index];

    allocation[pindex][index]-=request[index];

    pneed[pindex][index]+=request[index];

    }//回滚与模拟分配刚好相反

    }intcheckIsSafe()

    {int index=0;int index_=0;int count=0;int k=0;inttemp[PNUMBER];//余下的资源要保证每一个进程都能得到资源

    int finish[PNUMBER]={0,0,0,0,0};//资源

    intwork[SNUMBER];for(index=0;index

    {

    work[index]=avalable[index];

    }//所有进程找到

    for(index=0;index

    {

    count=0;if(finish[index]==1)continue;//余下的资源是否能满足某一进程的需要

    for(index_=0;index_

    {if(pneed[index][index_]<=work[index_])

    {

    count++;

    }if(count==SNUMBER)

    {//余下的资源如果满足一个进程的需要,也就能回收

    finish[index]=1;for(index_=0;index_

    {

    work[index_]+=allocation[index][index_];

    }//记下此进程的编号

    temp[k]=index;

    k++;//因为有资源回收,所以让所有进程试试看能不能重新分配

    index=-1;

    }

    }

    }//判断所有进程理论上是否能分配到资源

    for(index=0;index

    {//只要有一个进程分配不到资源,则不存在安全序列

    if(finish[index]==0)

    {

    printf("***不存在安全序列***");return 0;

    }

    }

    printf("安全序列............\n");for(index=0;index

    {

    printf("%d--->",temp[index]);

    }

    printf("\n");return 1;

    }

    展开全文
  • 操作系统中的FCFS算法

    2015-04-15 13:42:49
    操作系统中的FCFS算法,用C语言进行编写,代码简单明了,并且实现了六十进制和百进制之间的转换,易于初学操作系统的人更加了解FCFS算法
  • SJF | RR | HRN | FCFS算法

    2021-12-02 20:39:50
    SJF | RR | HRN | FCFS算法
  • FCFS算法

    万次阅读 2018-10-29 12:34:30
    原理:  按照作业进入系统的先后次序来挑选作业,先进入系统的作业优先...FcFs.h: #define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct PCB { ...
  • cout运行FCFS"; cout退出"; cout请输入:"; } void Input() { for(int b=0;b;b++) { cout作业号(0~2):"; cin>>jobline[b].Id; cout到达时间:"; cin>>jobline[b].Arrtime; cout运行时间:"; cin>>jobline[b...
  • 教育资料 xx大学 操作系统 实验报告 姓名 学号 班级 实验日期 实验名称先来先服务FCFS和短作业优先SJF进程调度算法 实验一 先来先服务FCFS和短作业优先SJF进程调度算法 1. 实验目的 通过这次实验理解FCFS和SJF进程...
  • OS实验报告--FCFS算法

    2016-04-15 12:48:00
    (1)加深对作业调度算法的理解; (2)进行程序设计的训练。 二、实验内容和要求 (1)实验要求  用高级语言编写一个或多个作业调度的模拟程序。  单道批处理系统的作业调度程序。作业一投入运行,它就占有...
  • FCFS算法 c++语言

    2010-10-26 15:06:05
    FCFS算法 c++语言FCFS算法 c++语言FCFS算法 c++语言
  • 操作系统中的先来先服务算法fcfs和多级反馈队列调度算法mfq
  • FCFS算法 操作系统

    2009-11-06 23:41:53
    简单易懂的先来先服务算法 Word格式 c++源码
  • FCFS算法设计

    千次阅读 2018-11-12 19:57:03
    FCFS先来先服务算法FCFS的基本思想我的设计思路图解我的代码: FCFS的基本思想 先来先服务就是一个思想,谁先到先执行谁,也就是谁在任务队列等待时间越长越先被执行(相同度量下,就是在考虑谁先出队就要重新更新一...
  • 实 验 报 告 题目 C 语言实现调度算法程序设计实验报告 -先来先服务 FCFS 名称 院系 a 班级 完成时间 指导老师 本次实验 成绩 算法原理 设计程序模拟进程的先来先服务 FCFS过程假设有 n 个进程分别 1 n 1 n 在 T , ,...
  • 操作系统FCFS算法

    2009-10-17 20:41:32
    操作系统的调度算法中的先来先服务算法FCFS,自己写的,恩,反正运行还好啦
  • 【操作系统】FCFS算法

    千次阅读 2019-07-30 08:55:29
    假定在一个处理机上执行的操作如下: 作业 估计服务时间 ... FCFS算法(First come first served):先来先服务算法:根据进程到达时间决定先运行哪个进程 有点类似于FIFO先进先出算法,是属于非抢占型(一旦...
  • linux进程fcfs进程调度算法c++模拟实现,自定义结构体,依据到达时间对进程先后顺序排序并输出排序结果(进程名,到达时间,服务时间)
  • 调度算法FCFS调度算法详解

    万次阅读 2020-06-11 18:45:17
    详解我自身理解的FCFS算法的实现思路,附代码
  • 操作系统实验报告 C++实现进程调度算法,短进程优先SJF与先来先服务FCFS算法
  • 文章目录一、先来先服务(FCFS)调度算法二、最短作业优先(SJF)算法1. 非抢占式SJF2. 抢占式SJF三、优先级调度算法1. 非抢占式优先级调度算法2. 抢占式优先级调度算法四、时间片轮转(RR)算法五、多级队列调度 一...
  • 快速实现FCFS算法和SPF算法 先来看看代码的总体结构: 在如上图的流程中,FCFS算法和SJF算法唯一的区别就是中间步骤的排序方法不同。因此,只需要替换代码中的排序方法即可。 本程序中,默认是FCFS算法,如果需要...
  • 最近在复习调度算法,又重拾了这种感觉,他俩太像了,电脑就是模仿人脑的机制制造出来的,但现在我们可以反过来从它身上学习一些优秀的算法,反哺自身(可能早已遗忘的)做事方法。什么是调度算法调度,你就理解成...
  • OS-实现一个FCFS调度算法 原理 FCFS也叫先来先服务调度算法,是非常简单的一种调度算法,他基于队列的排队思想,调度器必须排队处理加入队列的任务,不能进行抢占,我们只需要使用一个队列的数据结构就能够很方便的...
  • 简易FCFS算法

    2021-10-13 22:33:29
    } void fcfs(int n) { sumzztime=0; psumzztime=0; for(i=1;i;i++) { for(j=1;j;j++) { if(arrivetime[j]>arrivetime[j+1]) { ctp=arrivetime[j]; arrivetime[j]=arrivetime[j+1]; ...
  • 磁盘调度算法(FCFS、SSTF)例题

    千次阅读 2021-12-19 18:50:05
    先来先服务(FCFS,first-come first-service)根据进程请求访问磁盘的先后次序进行调度。 最短寻道时间优先(SSTF,Shortest Seek Time First)选择访问的磁道与当前磁头所在的磁道距离最近的进程,以使每次的寻道时间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,955
精华内容 4,382
关键字:

FCFS算法