循环队列--进程调度模拟--leastLaxityFirst（LLF）--就绪队列--阻塞队列--PCB--类比PCB（索引表）

循环队列简介：

采用数组实现：一个数组data，存储数据元素；双指针，即首指针front尾指针rear（由于是数组，所以int变量即可）,元素进队列，先判满，可以进则从尾指针处进，随后进行

rear = (rear+1)%queuesize;；元素出队列，先判空，可以出，则从front出，随后进行

front = （front+1）%queuesize;

循环队列实现

struct sqqueue {
    //int data[queSize];//假设队列中放的是int类型数据
    int front,rear;
}

循环队列 判空：front == rear; 判满 (rear+1)%queuesize == front

循环队列遍历的方法：

如遍历队列dui，先获取队列的front和rear指针，即int front = dui->front, rear = dui->rear;终止条件front == rear;每次，进行指针移动，更新条件是：下面两个语句二选一，固定rear，移动front，

front = (front+1)%queuesize;固定front，移动rear，rear = (rear+1)%queuesize;循环体：根据实际情况，对队列元素进行查询修改等操作。  

模拟最低松弛度调度算法

//最低松弛度调度算法LLF
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#define queuesize 10
#define MAXTIME 150 
#define MINLLF 9999
#define PRO_LRU_T 0
using namespace std;
const int queueSize = 10;
const int maxTime = 100;
const int MIN_LLF = 9999;
struct process {
	char pname[5]; int cycle;//队列中进程的键--进程名和当前循环次数
	int deadTime; int serveTime;//进程周期//每个周期内进程需要执行的总时间数
	int arriveTime; int lateStartTime; int leftTime;//进程到达时间，//进程最晚开始时间//当前周期内进程剩余执行时间
	int statement;//进程状态
	int LRU_t;//计数器，用于llf选择最低松弛度算法
};
void InitProcessSingle(process* pro) {
	*(pro->pname) = '\0';
	pro->cycle = 0;
	pro->deadTime = 0;
	pro->serveTime = 0;
	pro->arriveTime = 0;
	pro->lateStartTime = 0;
	pro->leftTime = 0;
	pro->statement = 0;
	pro->LRU_t = 0;
}
void InitProcess(process* pro, int n) {
	process* p = pro;
	for (int i = 0; i < n; i++)
		InitProcessSingle(p + i);
}
struct sqqueue {
	process* data[queueSize];
	int front, rear;
};
void InitQueue(sqqueue* dui) {
	dui->front = dui->rear = 0;
}
void enterQueue(sqqueue* que, process* pro) {
	if ((que->rear + 1) % queueSize == que->front)printf("队列已经满了\n");
	else {
		que->data[que->rear] = pro;
		que->rear = (que->rear + 1) % queueSize;
		printf("%s成功入队！\n", pro->pname);
	}
}
process* llf(sqqueue* dui, int currentTime) {//求当前松弛度最低的进程 
	sqqueue* que = dui;
	int front = que->front, rear = que->rear;
	process* currentPro = que->data[front], * pro = NULL;
	int minllf = MIN_LLF, llf;
	int LRU_t_max = 0;
	if (currentTime <= maxTime) {
		if (front == rear) { return currentPro; }
		else {
			do {
				if (front != rear) {
					pro = que->data[front];
					if (pro->arriveTime <= currentTime && currentTime <= maxTime) {
						llf = pro->lateStartTime - currentTime;
						if (minllf >= llf) {
							if (LRU_t_max <= pro->LRU_t) {
								minllf = llf;
								currentPro = pro;
								LRU_t_max = pro->LRU_t;
							}
						}
					}
					front = (front + 1) % queueSize;
				}
				else break;
			} while (front != rear);
		}
	}
	return currentPro;
}
process* leastLaxityFirst(sqqueue* dui, int currentTime) {//求当前松弛度是0的进程 
	sqqueue* que = dui;
	int front = que->front, rear = que->rear;
	process* currentPro = NULL, * pro = NULL;
	while (front != rear) {
		pro = que->data[front];
		if (pro->lateStartTime <= currentTime) {
			break;
		}else front = (front + 1) % queueSize;
	} 
	if (front == rear)return currentPro;
	else
		return pro;
}
void LLF_Process(sqqueue* dui) {
	int currentTime = 0;
	sqqueue* que = dui;
	int front = que->front; int rear = que->rear;
	process* currentProcess, * Process, * TmpProcess;
	currentProcess = llf(que, currentTime);
	while (currentTime <= maxTime) {
		if (currentProcess == NULL) {
			printf("当前%dms没有进程，退出\n", currentTime);
			break;
		}
		else
		{
			if (currentProcess->arriveTime <= currentTime) {//当前时间有进程到达 
				if (currentTime == maxTime) {//到达结尾时间，在运行的就输出当前时间结束 ，不在运行的输出时间到，不必再运行 
					if (currentProcess->statement == 0) {
						printf("当前只执行前%dms，所有进程都停止执行", maxTime);
						break;
					}
					else {
						currentProcess->statement == 0;
						printf("%dms  %s%d\n\n", currentTime, currentProcess->pname, currentProcess->cycle);
					}
				}
				else if(currentTime != maxTime)
				{//离结尾时间还远
					if (currentProcess->statement == 0) {
						currentProcess->statement = 1;
						printf("%dms进程%s%d开始执行\n", currentTime, currentProcess->pname, currentProcess->cycle);
					}
					else {
						printf("%d ms进程%s%d在执行，还剩%dms可以执行完\n", currentTime, currentProcess->pname, currentProcess->cycle, currentProcess->leftTime);
					}
					do {//更新LRU_t 
						if (front != rear) {
							Process = que->data[front];
							if (currentProcess != Process)Process->LRU_t++;
							front = (front + 1) % queueSize;
						}
						else break;
					} while (front != rear);
					//上面执行了第currentTime秒
					currentTime++;
					currentProcess->leftTime--;
					if (currentProcess->leftTime == 0) {
						if (currentProcess->statement == 1) {
							printf("%dms : %s%d\n\n", currentTime, currentProcess->pname, currentProcess->cycle);
							currentProcess->statement = 0;
						}
						currentProcess->cycle++;
						currentProcess->arriveTime = currentProcess->deadTime * (currentProcess->cycle - 1);
						currentProcess->leftTime = currentProcess->serveTime;
						currentProcess->lateStartTime = (currentProcess->deadTime) * (currentProcess->cycle) - currentProcess->serveTime;
						//currentProcess->statement = 0;
						currentProcess = llf(que, currentTime);
					}
					else {
						Process = leastLaxityFirst(que, currentTime);
						if (Process == NULL || Process == currentProcess)
							printf("当前%dms不存在抢占进程\n", currentTime);
						else {
							if (currentProcess->statement == 1)currentProcess->statement = 0;
							printf("%dms时，%s%d进程被%s%d进程抢占\n", currentTime, currentProcess->pname, currentProcess->cycle, Process->pname, Process->cycle);
							printf("%s%d进程：%dms\n", Process->pname, Process->cycle, currentTime);
							currentProcess = Process;
						}
					}
				}
			}
			else if(currentTime<=currentProcess->arriveTime){//当前时间没有进程到达
				if (currentTime < maxTime)
					printf("当前时间%dms没有进程到达\n", currentTime);
				if (currentTime == maxTime) {
					printf("程序模拟运行到%dms就停止，当前时间是%dms,时间到\n", maxTime, currentTime);
				}
				currentTime++;
				//
				currentProcess = llf(que, currentTime);
			}
		}
	}return;
}
int main() {
	sqqueue* dui, * dui2;
	process* pro, pro2[queueSize], * pro3;
	int front, rear, ci = 0, pi = 0;
	int flag = 1, i;
	char ch, ch2, name[5];
	printf("\n*****最低松弛度算法*****\n\n");
	dui = (sqqueue*)malloc(sizeof(sqqueue)); dui->rear = dui->front = 0;
	dui2 = (sqqueue*)malloc(sizeof(sqqueue)); dui2->rear = dui2->front = 0;
	while (1) {
		i = 0;
		InitQueue(dui);
		InitProcess(pro2, queueSize);
		printf("请输入周期进程信息");
		while (flag) {
			pro = pro2 + i;
			printf("\n请输入进程名(5个字符内）\n");
			scanf("%s", pro->pname); getchar();
			printf("\n请输入进程周期\n");
			scanf("%d", &(pro->deadTime)); getchar();
			printf("\n请输入进程执行时间\n");
			scanf("%d", &(pro->serveTime)); getchar();
			pro->cycle = 1;
			pro->arriveTime = pro->deadTime * (pro->cycle - 1);
			pro->leftTime = pro->serveTime;
			pro->lateStartTime = (pro->deadTime) * (pro->cycle) - pro->serveTime;
			pro->statement = 0;
			enterQueue(dui, pro);
			i++;
			printf("\n是否继续输入进程信息（0:结束，1：继续）\n");
			scanf("%d", &flag);
		}
		dui2 = dui; front = dui2->front; rear = dui2->rear;
		while (front != rear) {
			pro3 = dui2->data[front];
			ci += pro3->serveTime;
			pi += pro3->deadTime;
			front = (front + 1) % queueSize;
		}
		if ((ci / pi) <= 1) {
			LLF_Process(dui);
			printf("\n*****进程运行结束*****\n\n");
			printf("\n是否要结束使用（Y/N）？\n");
			cin>>ch; getchar();
			if (toupper(ch) == 'Y') {
				printf("\n 任意键结束\n");
				scanf("%c", &ch2);
				exit(0);
			}
			else flag = 1;
		}
		else {
			printf("输入的进程不满足要求");
			printf("\n是否要重新输入（Y/N）？");
			cin >> ch; getchar();
			if (ch == 'N') {
				printf("\n 任意键结束");
				scanf("%c", &ch2);
				exit(0);
			}
		}
	}
	free(dui);
	free(dui2);
	return 0;
}