在OS中调度的实质是一种资源的分配，因而调度算法是指，根据系统的资源分配策略所规定的资源分配算法，对于不同的系统和系统目标，通常采用不同的作业调度。如，在批处理系统中，为了照顾为数众多的短作业，应采用短作业优先的调度算法，又如在分时系统中，为了保证系统合理的响应时间，应采用轮转法进行调度。目前存在的调度算法中，有的算法用于作业调度，有的算法用于进程调度。

   先来先服务（FCFS）是一种最简单的调度算法，该算法即可用于作业调度，也可用于进程调度。

   FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。

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

struct  PCB
{
	char PName;
	double ArriveTime;
	double BusinessTime;
	double StartTime;
	double FinishTime;
	double TurnaroundTime;
	double RightTurnaroundTime;
	
	PCB();
	~PCB(){}	
};

PCB::PCB()
{
	PName='A';
	ArriveTime=0;
	BusinessTime=0;
	StartTime=0;
	FinishTime=0;
	TurnaroundTime=0;
	RightTurnaroundTime=0;	
}

void print(PCB p)
{
	//cout<<setiosflags(ios::left);
	cout<<p.PName<<setw(11)
	<<p.ArriveTime<<setw(11)
	<<p.BusinessTime<<setw(11)
	<<p.StartTime<<setw(11)
	<<p.FinishTime<<setw(11)
	<<p.TurnaroundTime<<setw(11)
	<<p.RightTurnaroundTime<<endl;	
}

void sort(PCB *pcb,int n)
{
	for(int i=0;i<n ;++i)
	{
		for(int j=i+1;j<n;++j)
		{
			if(pcb[i].ArriveTime<pcb[j].ArriveTime)
				continue;
			else if(pcb[i].ArriveTime==pcb[j].ArriveTime)
			{
				if(pcb[i].BusinessTime<=pcb[j].BusinessTime)
					;
				else
				{
					PCB swap;
					swap=pcb[i];
					pcb[i]=pcb[j];
					pcb[j]=swap;
				}
			}
			else if(pcb[i].ArriveTime > pcb[j].ArriveTime)
			{
				PCB swap;
				swap=pcb[i];
				pcb[i]=pcb[j];
				pcb[j]=swap;
			}
			
		}
	}	
}

void show(PCB *p,int n)
{
	cout<<"========================================================================"<<endl;
	cout<<"进程名   到达时间  服务时间  开始执行  完成时间  周转时间  带权周转时间"<<endl;	
	for(int i=0;i<n;++i)
	{
		print(p[i]);
		
	}
	cout<<"========================================================================="<<endl;
	cout<<endl;
}


void run(PCB *p,int n)
{
	double t=0.;
	cout<<"当前进程按时间顺序的就绪队列状态："<<endl;
	show(p,n);
	for(int i=0;i<n;++i)
	{
		p[i].StartTime=t;
		p[i].FinishTime=p[i].StartTime + p[i].BusinessTime;
		p[i].TurnaroundTime= p[i].FinishTime - p[i].ArriveTime;
		p[i].RightTurnaroundTime=p[i].TurnaroundTime / p[i].BusinessTime;
		t = p[i].FinishTime;
		
		getchar();
		cout<<"正在执行第"<<i+1<<"个进程 "<<p[i].PName<<" :"<<endl; 
		show(p,n);
	}
}


int main()
{
	int n;
	cout<<"请输入要创建的进程个数：";
	cin>>n;
	PCB pcb[n];
	cout<<"请输入进程名，到达时间，服务时间:"<<endl;
	
	for(int i=0;i<n;++i)
	{
		cin>>pcb[i].PName>>pcb[i].ArriveTime>>pcb[i].BusinessTime;
	}
	cout<<"需要执行的进程状态:"<<endl;
	show(pcb,n);
	
	//根据时间排序 
	sort(pcb,n);
	
	run(pcb,n);	
	return 0;
} 

一直按enter键，直到所有进程全部运行完。 

   算法中，对于进程到来时间相同的，就按进程所需运行时间进行比较。

调度算法--先来先服务