先来先服务调度算法的简单模拟

//调度算法的模拟
//1.FCFS

#include<stdio.h>
#include <malloc.h>
#include <string>
#include <string.h>
#include<iostream>
using namespace std;

struct PCB{
    string name;//进程name
	int reachTime;//标志进程到达时间
	int needTime;//进程所需的时间
	bool state;
	/*进程的状态，false表示挂起，true表示激活*/
	int alltime;//总共所用的时间，即周转时间
	bool over;   //进程的状态，true表示结束
}P[5];  //声明5个进程
void init();
void processSchedule();
void printPCB(PCB P);

int main(){
    init();  //初始化这五个进程
    processSchedule();//进程调度

    cout<<"进程名称"<<"\t"<<"到达时间"<<"\t"<<"所需时间"<<"\t"<<"周转时间"<<endl;
    for(int i = 0; i < 5; i++){
        printPCB(P[i]); //打印进程信息
    }

    return 0;
}

void init(){
    P[0].name = "P1";
    P[0].reachTime = 0;
    P[0].needTime = 4;
    P[0].state = 0;
    P[0].alltime = 0;
    P[0].over = 0;

    P[1].name = "P2";
    P[1].reachTime = 1;
    P[1].needTime = 3;
    P[1].state = 0;
    P[1].alltime = 0;
    P[1].over = 0;

    P[2].name = "P3";
    P[2].reachTime = 2;
    P[2].needTime = 5;
    P[2].state = 0;
    P[2].alltime = 0;
    P[2].over = 0;

    P[3].name = "P4";
    P[3].reachTime = 3;
    P[3].needTime = 2;
    P[3].state = 0;
    P[3].alltime = 0;
    P[3].over = 0;

    P[4].name = "P4";
    P[4].reachTime = 4;
    P[4].needTime = 4;
    P[4].state = 0;
    P[4].alltime = 0;
    P[4].over = 0;
}

void printPCB(PCB P){
    cout<<P.name<<"\t\t"<<P.reachTime<<"\t\t"<<P.needTime<<"\t\t"<<P.alltime<<endl;
}

void setState(){ //寻找没结束的进程中最早进入系统的进程并且将其置为激活状态
    for(int i = 0; i < 5; i++){
        if(!P[i].over){
            P[i].state = 1;
        }
    }
}

void processSchedule(){
    int all = 0; //记录系统运行总时间
    for(int n = 0; n < 5; n++){ //五个进程
        int time = 0;  //记录该进程执行时间
        setState();
        for(int i = 0; i < 5; i++){

            if(P[i].state){ //若该进程是激活状态，则进入if块
                while(true){ //死循环直到进程执行完毕，即执行时间等于所需的时间
                    all++;
                    time++;
                    if(time == P[i].needTime){
                        P[i].over = 1;
                        P[i].state = 0;
                        P[i].alltime = all - P[i].reachTime;
                        //总共的时间减去进程到达的时间就是进程的周转时间
                        break;
                    }
                }
                break;
            }
        }
    }
}