操作系统，时间片轮转算法的C语言实现Round Robin

#include "windows.h"
#include <conio.h>
#include <stdlib.h>
#include <fstream.h>
#include <io.h>
#include <string.h>
#include <stdio.h>

void Create_ProcInfo(); // 建立进程调度需要的数据
void Display_ProcInfo();   // 显示当前系统全部进程的状态
void Scheduler_FF();
void Cpu_Sched();
void IO_Sched();
void NextRunProcess();
void DisData();
void DisResult();

int   RunPoint;   // 运行进程指针，-1时为没有运行进程
int   WaitPoint;  // 阻塞队列指针，-1时为没有阻塞进程
int   ReadyPoint; // 就绪队列指针，-1时为没有就绪进程
long  ClockNumber;   // 系统时钟
int   ProcNumber;    // 系统中模拟产生的进程总数
int   FinishedProc;    // 系统中模拟产生的进程总数
int q=9;//时间片


//进程信息结构
struct ProcStruct  
{
    int  p_pid;         // 进程的标识号
    char p_state;       // 进程的状态，C--运行  R--就绪  W--组塞  B--后备  F--完成
    int  p_rserial[16]; // 模拟的进程执行的CPU和I/O时间数据序列，间隔存储，0项存储有效项数
    int  p_pos;         // 当前进程运行到的序列位置
    int  p_starttime;   // 进程建立时间
    int  p_endtime;     // 进程运行结束时间
    int  p_cputime;     // 当前运行时间段进程剩余的需要运行时间
    int  p_iotime;      // 当前I/O时间段进程剩余的I/O时间
    int  p_next;        // 进程控制块的链接指针
    int  p_excutetime;  // 记录一次时间片内执行的时间
} proc[10];

////////////////////////////////////////////////////////////////////////////
//
//  随机生成进程数量和每个CPU--I/O时间数据序列，进程数量控制在5到10之间， //
//  数据序列控制在6到12之间，CPU和I/O的时间数据值在5到15的范围           //
//
////////////////////////////////////////////////////////////////////////////

void Create_ProcInfo(void )
{
    int s,i,j;
    
    srand(GetTickCount());                        // 初始化随机数队列的"种子"
    ProcNumber=((float) rand() / 32767) * 5 ;  // 随机产生进程数量5~10

    
    for(i=0;i<ProcNumber;i++)    // 生成进程的CPU--I/O时间数据序列
    {  
        proc[i].p_pid=((float) rand() / 32767) * 1000;
        proc[i].p_state='B';   // 初始都为后备状态
        
        s=((float) rand() / 32767) *6 + 2; // 产生的进程数据序列长度在6~12间
        proc[i].p_rserial[0]=s; // 第一项用于记录序列的长度
        for(j=1;j<=s;j++)  // 生成时间数据序列
            proc[i].p_rserial[j]=((float) rand() / 32767) *10 + 5;
        // 赋其他字段的值
        proc[i].p_pos=1;
        proc[i].p_starttime=((float) rand() / 32767) *49+1;   // 随机设定进程建立时间
        proc[i].p_endtime=0;    
        proc[i].p_cputime=proc[i].p_rserial[1];  
        proc[i].p_iotime=proc[i].p_rserial[2];  
        proc[i].p_next=-1; 
        proc[i].p_excutetime=0;
    }     
    printf("
---------------------------
    建立了%2d 个进程数据序列

", ProcNumber);
    DisData();
    printf("
Press Any Key To Continue.......");
    _getch() ; 
    return ;
}

////////////////////////////////////////////////////////////////////////

//                        显示系统当前状态

////////////////////////////////////////////////////////////////////////

void Display_ProcInfo(void)
{  int i,n;

system("cls") ;
printf("时间片为%d",q);
printf("
        当前系统模拟%2d 个进程的运行    时钟：%ld

", ProcNumber,ClockNumber);

printf("        就绪指针=%d, 运行指针=%d, 阻塞指针=%d

",ReadyPoint,RunPoint,WaitPoint );
if(RunPoint!= -1)
{
       printf(" 当前运行的进程   No.%d ID：%d
", RunPoint,proc[RunPoint].p_pid);
       printf("              %6d,%6d,%6d
",proc[RunPoint].p_starttime,proc[RunPoint].p_rserial[proc[RunPoint].p_pos],proc[RunPoint].p_cputime);
       printf("当前运行的进程执行的时间为%d",proc[RunPoint].p_excutetime);
       printf("当前运行的进程执行的cpu时间为%d",proc[RunPoint].p_cputime);
}
else
printf(" 当前运行的进程ID：No Process Running !
");

n=ReadyPoint;
printf("
 Ready Process ...... 
");
while(n!=-1) // 显示就绪进程信息
{   
       printf("     No.%d ID:%5d,%6d,%6d,%6d
",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_cputime );
       n=proc[n].p_next;
}

n=WaitPoint;
printf("
 Waiting Process ...... 
");
while(n!=-1) // 显示阻塞进程信息
{   
       printf("     No.%d ID:%5d,%6d,%6d,%6d
",n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_iotime);
       n=proc[n].p_next;
}

printf("
=================== 后备进程 ====================
");
for(i=0; i<ProcNumber; i++) 
if (proc[i].p_state=='B')
printf("     No.%d ID:%5d,%6d
",i,proc[i].p_pid,proc[i].p_starttime); 

printf("
================ 已经完成的进程 =================
");
for(i=0; i<ProcNumber; i++) 
if (proc[i].p_state=='F')
printf("No.%d ID:%5d,%6d,%6d
",i,proc[i].p_pid,proc[i].p_starttime,proc[i].p_endtime);

}

////////////////////////////////////////////////////////////////////////

//              显示模拟执行的结果

////////////////////////////////////////////////////////////////////////
void DisResult(void)
{  int i;   
printf("
---------------------------------
");
for(i=0; i<ProcNumber; i++) 
{  
    printf("ID=%4d> %2d ",proc[i].p_pid ,proc[i].p_rserial[0] );
    printf("%4d,%4d",proc[i].p_starttime,proc[i].p_endtime);
    printf("
" );
}  
}

////////////////////////////////////////////////////////////////////////

//              显示进程数据序列

////////////////////////////////////////////////////////////////////////
void DisData(void)
{  int i,j;   

for(i=0; i<ProcNumber; i++) 
{  
    printf("ID=%4d %2d > ",proc[i].p_pid ,proc[i].p_rserial[0] );
    for(j=1; j<=proc[i].p_rserial[0];j++)
        printf("%4d",proc[i].p_rserial[j]);
    printf("
" );
}  
}
////////////////////////////////////////////////////////////////////////

//              选择下一个可以运行的进程

////////////////////////////////////////////////////////////////////////
void NextRunProcess(void)
{
    if (ReadyPoint==-1) { RunPoint = -1; return;}  // 就绪队列也没有等待的进程
    
       proc[ReadyPoint].p_state ='C';     //ReadyPoint所指示的进程状态变为执行状态  
       RunPoint=ReadyPoint;       
       if( proc[ReadyPoint].p_excutetime==-1)//进程为执行成功，接着上次的cpu时间执行
       {
            proc[ReadyPoint].p_excutetime=0;
       }
       else
       proc[ReadyPoint].p_cputime =proc[ReadyPoint].p_rserial[proc[ReadyPoint].p_pos] ;       
       ReadyPoint=proc[ReadyPoint].p_next;
       proc[RunPoint].p_next = -1;
       
}
////////////////////////////////////////////////////////////////////////

//              CPU调度

////////////////////////////////////////////////////////////////////////

void Cpu_Sched(void)
{ 
    int n;
    
    if (RunPoint == -1)    // 没有进程在CPU上执行
    {         NextRunProcess();    return;     }
    
    proc[RunPoint].p_cputime--;      // 进程CPU执行时间减少1个时钟单位
    proc[RunPoint].p_excutetime++;
    if((proc[RunPoint].p_cputime == 0&&proc[RunPoint].p_excutetime<=q))//若时间片未完，但进程已经结束
    {
        //printf("若时间片未完，但进程已经结束
");
        proc[RunPoint].p_excutetime=0;//清空运行时间
        // 进程完成本次CPU后的处理
        if (proc[RunPoint].p_rserial[0]==proc[RunPoint].p_pos) //进程全部序列执行完成
        {  
            FinishedProc++;
            proc[RunPoint].p_state ='F';
            proc[RunPoint].p_endtime = ClockNumber;    
            RunPoint=-1;  //无进程执行  
            NextRunProcess(); 
        }    
        else //进行IO操作，进入阻塞队列
        {
            proc[RunPoint].p_pos++;
            proc[RunPoint].p_state ='W';
            proc[RunPoint].p_iotime =proc[RunPoint].p_rserial[proc[RunPoint].p_pos];
            printf("进入阻塞队列
");
            n=WaitPoint;
            if(n == -1) //是阻塞队列第一个I/O进程
                WaitPoint=RunPoint; 
            else
            {    do //放入阻塞队列第尾
            {
                if(proc[n].p_next == -1) 
                { proc[n].p_next = RunPoint;                  
                break;
                }
                n=proc[n].p_next;
            } while(n!=-1) ;
            }
            RunPoint=-1;   
            NextRunProcess(); 
        }
        return;
    }
    if(proc[RunPoint].p_cputime > 0&&proc[RunPoint].p_excutetime<q)//时间片未完 程序未执行结束 继续执行
    {
        //printf("时间片未完 程序未执行结束 继续执行
");
        return;
    }
    //{ printf("
 RunPoint=%d,ctime=%d",RunPoint,proc[RunPoint].p_cputime);getchar();return; }
    if(proc[RunPoint].p_cputime > 0&&proc[RunPoint].p_excutetime==q)//时间片完，但是程序未执行完 放到就绪队列尾部
    {
        //printf("时间片完，但是程序未执行完 放到就绪队列尾部
");
        int n;  
        proc[RunPoint].p_state='R';     //    进程状态修改为就绪            
        proc[RunPoint].p_next=-1;
        proc[RunPoint].p_excutetime=-1;//清空运行时间,-1代表程序未执行完成
        if(ReadyPoint==-1) // 就绪队列无进程
            ReadyPoint=RunPoint;
        else      // 就绪队列有进程，放入队列尾
        {     
            n=ReadyPoint;               
            while(proc[n].p_next!=-1) n=proc[n].p_next;
            proc[n].p_next=RunPoint;
        }
        RunPoint=-1;
        NextRunProcess(); //执行下一个进程
    }

}



////////////////////////////////////////////////////////////////////////

//              I/O调度

////////////////////////////////////////////////////////////////////////

void IO_Sched(void)
{ 
    int n,bk;
    
    if (WaitPoint==-1) return;   // 没有等待I/O的进程，直接返回
    
    proc[WaitPoint].p_iotime--;  // 进行1个时钟的I/O时间 
    
    if (proc[WaitPoint].p_iotime > 0) return; // 还没有完成本次I/O
    
    // 进程的I/O完成处理
    if (proc[WaitPoint].p_rserial[0]==proc[WaitPoint].p_pos) //进程全部任务执行完成
    {  
        FinishedProc++;
        proc[WaitPoint].p_endtime = ClockNumber;
        proc[WaitPoint].p_state ='F';    
        
        if(proc[WaitPoint].p_next==-1)
        { WaitPoint=-1;return ;}
        else //调度下一个进程进行I/O操作
        {
            n=proc[WaitPoint].p_next;
            proc[WaitPoint].p_next=-1;
            WaitPoint=n;
            proc[WaitPoint].p_iotime =proc[WaitPoint].p_rserial[proc[WaitPoint].p_pos] ;
            return ;
        }    
    }
    else //进行下次CPU操作，进就绪队列
    {        
        bk=WaitPoint;
        WaitPoint=proc[WaitPoint].p_next;
        
        proc[bk].p_pos++;
        proc[bk].p_state ='R'; //进程状态为就绪
        proc[bk].p_cputime = proc[bk].p_rserial[proc[bk].p_pos];
        proc[bk].p_next =-1;
        
        n=ReadyPoint;   
        if(n == -1) //是就绪队列的第一个进程
        {  ReadyPoint=bk;    return;    } 
        else
        {  do 
        {
            if(proc[n].p_next == -1) { proc[n].p_next = bk;  break ; }
            n=proc[n].p_next;
        }
        while(n!=-1); 
        }
    }
    return ;
}





////////////////////////////////////////////////////////////////////////

//              检查是否有新进程到达，有则放入就绪队列

////////////////////////////////////////////////////////////////////////

void NewReadyProc(void)
{ 
    int i,n;
    
    for(i=0; i<ProcNumber; i++) 
    {    
        if (proc[i].p_starttime == ClockNumber) // 进程进入时间达到系统时间
        {   
            proc[i].p_state='R';     //    进程状态修改为就绪            
            proc[i].p_next=-1;
            
            if(ReadyPoint==-1) // 就绪队列无进程
                ReadyPoint=i;
            else      // 就绪队列有进程，放入队列尾
            {     
                n=ReadyPoint;               
                while(proc[n].p_next!=-1) n=proc[n].p_next;
                proc[n].p_next=i;
            }
        }
    } // for
    return;       
}


////////////////////////////////////////////////////////////////////////

//                         调度模拟算法

////////////////////////////////////////////////////////////////////////

void Scheduler_FF(void)
{
    FinishedProc=0;
    if(ProcNumber==0)
    { printf("    必须首先建立进程调度数据 ！  
");
    system("cls");    return;
    }
    
    ClockNumber=0;// 时钟开始计时, 开始调度模拟
    while(FinishedProc < ProcNumber) // 执行算法
    {     
        ClockNumber++;  // 时钟前进1个单位
        NewReadyProc(); // 判别新进程是否到达
        Cpu_Sched();    // CPU调度
        IO_Sched();     // IO调度      
        Display_ProcInfo(); //显示当前状态
    }
    DisResult(); 
    getch();   return;
}

void Change_q(void)
{
  scanf("%d",&q);
}

///////////////////////////////////////////////////////////////////

//                          主函数

///////////////////////////////////////////////////////////////////

int main(int argc, char* argv[])
{
    char ch;
    
    RunPoint=-1;   // 运行进程指针，-1时为没有运行进程
    WaitPoint=-1;  // 阻塞队列指针，-1时为没有阻塞进程
    ReadyPoint=-1; // 就绪队列指针，-1时为没有就绪进程
    ClockNumber=0;   // 系统时钟
    ProcNumber=0;    // 当前系统中的进程总数
    
    system("cls") ;
    while ( true )                           
    {
        printf("***********************************
");
        printf("     1: 建立进程调度数据序列 
") ;
        printf("     2: 执行调度算法
") ;
        printf("     3: 显示调度结果 
") ;
        printf("     4: 更改时间片 
");
        printf("     5: 退出
") ;
        printf("***********************************
");
        printf( "Enter your choice (1 ~ 5): ");  
        
        do{   //如果输入信息不正确，继续输入
            ch = (char)_getch() ;
        } while(ch != '1' && ch != '2'&& ch != '3'&& ch != '4'&& ch != '5');
        
        if(ch == '5') { printf( "
");return 0; }   // 选择4，退出       
        if(ch == '3') DisResult();        // 选择3        
        if(ch == '2') Scheduler_FF();     // 选择2        
        if(ch == '1') Create_ProcInfo();  // 选择1        
        if(ch == '4') Change_q();
        _getch() ; 
        system("cls") ;
    }
    //结束
    printf("
Press Any Key To Continue:");
    _getch() ; 
    return 0;
}