c语言实现进程调度优先权调度算法和时间片轮转调度算法

**

1.算法原理

**
时间片轮转调度算法

1. a.在时间片轮转调度算法中，系统根据先来先服务的原则，将所有的就绪进程排成一个就绪队列，并且每隔一段时间产生一次中断，激活系统中的进程调度程序，完成一次处理机调度，把处理机分配给就绪队列队首进程，让其执行指令。当时间片结束或进程执行结束，系统再次将cpu分配给队首进程。
2. b.时间片尚未结束，进程已经执行结束，立即激活调度程序，将其从就绪队列中删除，在调度就绪队列的队首进程执行，开启新的时间片（计数器置0）。时间片已经结束，进程尚未结束，立即激活进程调度程序，未执行完的进程放到就绪队列的队尾。
3. c.在轮转调度算法中时间片的大小对系统的性能有很大的影响。若时间片很小，将有利于短作业，其能够在这个时间片内完成。时间片过小意味着会进行频繁的进程切换，这将增大系统的开销。若时间片选择太长，时间片轮转调度算法将退化为先来先服务的进程调度算法。

优先权调度算法

1. a.N进程采用动态优先权算法的进程调度；
2. b．每个用来标识进程的进程控制块PCB用结构描述，包括以下字段：进程标识数ID，进程优先数PRIORITY，进程以占用的CPU时间CPUTIME，进程还需占用的CPU时间ALLTIME，进程状态STATE等。
3. c．优先数改变的原则：进程在就绪队列中呆一个时间片，优先数增加1，进程每运行一个时间片优先数减3。
4. d．设置调度前的初始状态。
5. e．将每个时间片内的进程情况显示出来

c语言实现

//时间片轮转法
#include
#include
#include
using namespace std;
struct Node {
	char name;
	int Tarrive;//到达时间
	int Tservice;//服务时间
	int Tsurplus;//剩余时间
	int Tstart;//开始时间
	int Taccomplish;//完成时间
	int prio;//优先级---数字越大优先级越高
	int if_finish;//进程是否完成
	int num;//进程个数
}job[10];
//按到达时间排序
void Arrive_sort(int num)
{
	int temp1, temp2, temp3;
	for (int i = 0; i < num; i++)
	{
		for (int j = i + 1; j < num; j++)
		{
			if (job[i].Tarrive > job[j].Tarrive)
			{
				temp1 = job[j].name;
				job[j].name = job[i].name;
				job[i].name = temp1;
				temp2 = job[j].Tarrive;
				job[j].Tarrive = job[i].Tarrive;
				job[i].Tarrive = temp2;
				temp3 = job[j].Tservice;
				job[j].Tservice = job[i].Tservice;
				job[i].Tservice = temp3;
			}
		}
	}
}

void RR(int num)//RR算法
{
	int q;
	cout << "请输入时间片长度：" << endl;
	cin >> q;
	int flag = 1;//标志队列中是否还有进程
	int finish_pro = 0;//完成的进程数
	cout << "进程名称\t" << "开始时间\t" << "运行时间\t" << "剩余服务时间\t" << "结束时间\t" << endl;
	int time;//记录当前时刻时间
	int c = 0;
	while (finish_pro < num)
	{
		flag = 0;//就绪队列里没进程
		for (int i = c; i < num; i++)
		{
			Arrive_sort(num);
			job[i].Tsurplus = job[i].Tservice;
			job[i].Tstart = job[i - 1].Taccomplish;//上一个作业结束时间
			if (job[i].Tstart < job[i].Tarrive)//该作业的开始时间小于到达时间
			{
				job[i].Tstart = job[i].Tarrive;
			}
			else
			{
				job[i].Tstart = job[i - 1].Taccomplish;
			}
			time = job[i].Tstart;
			if (job[i].if_finish == 1) continue;//该进程已完成
			else
			{
				if (job[i].Tsurplus <= q && time >= job[i].Tarrive)//未完成且少于一个时间片
				{
					flag = 1;
					time = time + job[i].Tsurplus;
					job[i].if_finish = 1;//该进程完成
					job[i].Taccomplish = time;
					cout  << job[i].name << "\t\t" << job[i].Taccomplish - job[i].Tsurplus << "\t\t" << job[i].Tsurplus << "\t\t" << 0 << "\t\t" << job[i].Taccomplish << endl;
					job[i].Tsurplus = 0;
				}
				else if (job[i].Tsurplus > q && time >= job[i].Tarrive)
				{
					flag = 1;
					time = time + q;
					job[i].Tsurplus -= q;
					job[i].Taccomplish = time;
					cout << job[i].name << "\t\t" << time - q << "\t\t" << q << "\t\t" << job[i].Tsurplus << "\t\t" << job[i].Taccomplish << endl;
					job[num].name = job[i].name;
					job[num].Tarrive = time;
					job[num].Tservice = job[i].Tsurplus;
					num++;
				}
				if (job[i].if_finish == 1) finish_pro++;//一个进程完成加一
			}
			c++;
		}break;
		if (flag == 0 && finish_pro < num)//没执行完且没进入就绪队列
		{
			for (int i = 0; i < num; i++)
			{
				if (job[i].if_finish == 0)
				{
					time = job[i].Tarrive;
					break;
				}
			}
		}
	}	
}
//输出
void print(int num)
{
	cout << "进程名" << "\t" << "到达时间" << "\t" << "服务时间" << "\t" << "完成时间" << endl;
 
	for (int i = 0; i < num; i++)
	{
		cout << job[i].name << "\t" << job[i].Tarrive << "\t\t" << job[i].Tservice << "\t\t" << job[i].Taccomplish << endl;
	}
}
void display(int num)
{
		
			RR(num);
}
int main()
{
	int num;
	char jname;
	int arrive;
	int service;
	int accomplish;
	cout << "请输入进程个数：" << endl;
	cin >> num;
	for (int i = 0; i < num; i++)
	{
		cout << "请输入进程名、到达时间、服务时间" << endl;
		cin >> jname;
		job[i].name = jname;
		cin >> arrive;
		job[i].Tarrive = arrive;
		cin >> service;
		job[i].Tservice = service;
	}
	display(num);
	return 0;
}
//动态优先级算法
#include
#include

typedef struct PCB{
    int PID;
    char state;
    int priority;
    int runTime;
    int workTime;
    struct PCB *next;
}*process,ptr;

PCB *ready=NULL,*p;
int num;

void PCBsort(){
    PCB *first,*second;
    int flag=0;
    if((ready==NULL)||((p->priority)<(ready->priority))){
        p->next=ready;
        ready = p;
    }else{
        first=ready;
        second=first->next;
        while(second!=NULL){
            if((p->priority)<(second->priority)){
                p->next=second;
                first->next=p;
                second=NULL;
                flag=1;
            }else{
                first=first->next;
                second=second->next;
            }
        }
        if(flag==0)first->next=p;
    }
}

void inputProcess()
{
    int i;
    printf("输入%d个进程的信息（PID、优先级、运行时间）\n",num);
    for(i=0;iPID,&p->priority,&p->runTime);
        p->workTime=0;
        p->state='w';
        p->next=NULL;
        PCBsort();
    }
}

int space()
{
    int k=0;
    PCB* pr=ready;
    while(pr!=NULL){
        k++;
        pr=pr->next;
    }
    return k;
}

void showInfo(ptr *pr){
    printf("\nPID\t状态\t优先级\t运行时间\t剩余时间\n");
    printf("————————————————————————————\n");
    printf(" %d\t",pr->PID);
    printf(" %c\t",pr->state);
    printf("%d\t",pr->priority);
    printf("%d\t\t",pr->runTime);
    printf("%d\t",pr->runTime-pr->workTime);
    printf("\n");
}

void priorityRun()
{
    int len,h=0;
    char ch;
    inputProcess();
    len=space();
    while((len!=0)&&(ready!=NULL))
    {
        ch=getchar();
        h++;
        printf("\n 运行次数:%d \n",h);
        p=ready;
        ready=p->next;
        p->next=NULL;
        p->state='R';
        PCB* pr;
        showInfo(p);
        pr=ready;
        while(pr!=NULL){
            showInfo(pr);
            pr=pr->next;
        }
        (p->workTime)++;
        if(p->workTime==p->runTime){
            printf("\n 进程%d 已结束。\n",p->PID);
            free(p);
        }
        else{
            (p->priority)++;
            p->state='w';
            PCBsort();
        }
        printf("\n 按任一键继续 ......");
    }
    printf("\n\n 进程已经完成 .\n");
    ch=getchar();
}

int main()
{
    printf("—————————————————优先级调度算法—————————————————\n");
    printf("输入进程数目：");
    scanf("%d",&num);
    priorityRun();
}