最低鬆弛度優先（LLF）算法是根據任務緊急（或鬆弛）的程度，來確定任務的優先級。任務的緊急程度愈高，爲該任務所賦予的優先級就愈高，使之優先執行。在實現該算法時要求系統中有一個按鬆弛度排序的實時任務就緒隊列，鬆弛度最低的任務排在隊列最前面，被優先調度。鬆弛度的計算方法如下：
任務的鬆弛度=必須完成的時間-其本身的運行時間-當前時間
其中其本身運行的時間指任務運行結束還需多少時間，如果任務已經運行了一部分，則：
任務鬆弛度=任務的處理時間-任務已經運行的時間 – 當前時間
幾個注意點：
1. 該算法主要用於可搶佔調度方式中，當一任務的最低鬆弛度減爲0時，它必須立即搶佔CPU，以保證按截止時間的要求完成任務。
2. 計算關鍵時間點的各進程週期的鬆弛度，當進程在當前週期截止時間前完成了任務，則在該進程進入下個週期前，無需計算它的鬆弛度。
3. 當出現多個進程鬆弛度相同且爲最小時，按照“最近最久未調度”的原則進行進程調度。
1、結構體描述進程
定義及其意義如下：
typedef struct process //進程
{
char pname[5]; //進程名
int deadtime; //週期
int servetime; //執行時間
//週期進程某一次執行到停止的剩餘需執行時間（考慮到搶佔），初始爲deadtime
int lefttime;
int cycle; //執行到的週期數
//進程最近一次的最遲開始執行時間，- currenttime 即爲鬆弛度
int latestarttime;
//進程下一次最早開始時間
int arivetime;
intk; //k=1，表示進程正在運行，否則爲0，表示進程不在執行期間
/*
若存在最小松弛度進程個數多於1個，
則採用最近最久未使用算法
採用一計數器LRU_t
*/
intLRU_t;
}process;
2、循環隊列存儲進程
定義及其意義如下：
typedef struct sqqueue //循環隊列
{
process *data[queuesize];
int front,rear;
} sqqueue;
重難點分析
1、實時系統可調度條件
當實時系統中有M個硬實時任務，它們的處理時間可表示爲Ci ，週期時間表示爲Pi，則在採用N個處理機的系統中，必須滿足限制條件：
Σ<=N
系統纔是可調度的。現在單處理機下，即Σ<=1，否則認爲不滿足實時系統調度條件。
2、進程的結構體描述
typedefstruct process //進程
{
char pname[5];
int deadtime;
int servetime;
int lefttime;
int cycle;
int latestarttime;
int arivetime;
intk;
intLRU_t;
}process;
進程首先包括進程名pname、週期時間deadtime、執行時間servetime；
爲控制週期進程的執行週期數，應有一個進程計數cycle，初始化爲1；
因爲是實時系統中的進程，該有一個進程執行最早開始時間arivetime和最晚開始時間latestarttime；
考慮到進程搶佔，所以有一個進程某一次執行中斷後的剩餘執行時間，需用於計算鬆弛度。
還可以有一個進程運行狀態位k，1即表示正在運行，0則表示沒有運行。
當出現多個進程鬆弛度相同且爲最小時，按照“最近最久未調度”的原則進行進程調度。所以有一個計數器LRU_t計算每一個進程在調度時，調度與被調度的情況。初始均爲0，調度某一進程時，則該進程以外的其他進程均要在計數器上加1。鬆弛度相同時，選擇計數器LRU_t值最大的。
補充說明：最開始時，我們沒有考慮進程運行狀態位k，後來是爲了輸出進程的執行開始和結束時間而加的，可以根據進程的運行狀態位，進行輸出進程的執行時間段。
對於出現多個進程鬆弛度相同且爲最小時，最開始選擇的是每次都採用最接近隊尾的進程，這樣雖然滿足對於題目所給的實例，但是實際上是還是不符要求的，最後選擇最近最久未使用算法的思想得以解決。
3、循環隊列的屬性及遍歷
隊列中的進程以數組的形式進程存儲；
隊列的隊首爲front，隊尾爲rear，遍歷時要考慮隊空否，或者輸入進程時，要考慮進程是否填滿了隊列。
循環隊列，隊空爲：front == rear
隊滿爲：(rear+1)%queuesize == front
4、鬆弛度的計算
鬆弛度 = 任務必須完成的時間 — 任務本身的運行時間 — 當前時間；
即鬆弛度 = 週期*需執行的次數 —（上一次）執行的剩餘時間 —當前時間
即鬆弛度= deadtime× cycle — lefttime — currenttime
而（可能被中斷過）進程最遲開始執行時間arivetime = deadtime× cycle —lefttime
所以arivetime— currenttime <=0 ，即爲鬆弛度爲0，搶佔當前正在運行進程。
5、最小松弛度的進程
採用遍歷隊列中當前時間下可以開始運行的進程，即最早開始時間arivetime=deadtime*( cycle-1) 小於當前時間，比較各進程鬆弛度，得出最小松弛度的進程。
6、進程的搶佔
由上可知進程的鬆弛度的計算方法，依舊採用遍歷隊列的方式，循環尋找鬆弛度爲0 的進程：如果存在就讓其跳出循環，返回該進程；否則，隊首指針向下，直至隊尾，如果遍歷完都不存在鬆弛度爲0的進程，則返回當前進程即可。但未考慮鬆弛度同時爲0的進程存在多個的情況。
7、時鐘
由於是實時系統，我們採用時鐘計時法。即在每1ms的時間變化時，都要進行LLF進程的選擇。即在當前時間currenttime下，currenttime初始爲0，循環++，直至到達執行總時間MAXTIME。
8、最低鬆弛度相同的若干進程調度
對於出現多個進程鬆弛度相同且爲最小時，選擇的原則是，剛剛執行過的進程，此時應不再執行，讓給其他具有同樣最低鬆弛度的進程。
最開始選擇的是每次都採用最接近隊尾的進程。在遍歷的過程中，將當前隊列賦給一臨時隊列，對臨時隊列進行遍歷，所以並不改變原隊列的隊首隊尾指針。在每次選擇最低鬆弛度的進程時，我們都是選擇離隊尾最近的進程，但這樣存在着問題，例如：A：50ms（週期），10（執行時間），B：20ms（週期），10（執行時間），C：50ms（週期），15（執行時間），在第80ms時還是在執行完B4後，執行B5，而非A2。
這樣雖然滿足對於題目所給的實例，但是實際上是還是不符要求的。最後選擇最近最久未使用（LRU）算法的思想得以解決。即給每一個進程設置一個計數器。
9、currenttime 在邊界值時的情況
在currenttime == MAXTIME時，可能存在進程正好要開始執行，例如題目所給的例子：100ms時，A進程要開始執行，但是我們不應讓其開始執行，所以應該臨界處理；
同理，可能也存在進程正在執行當中，此時應該輸出該進程在沒有完成其週期執行時間的下的運行時間段。
10、當前時間沒有進程運行的情況
假若只有一個進程，週期時間是20ms，執行時間是10ms，那麼在10—20ms、30—40ms、50—60ms……時，是沒有進程運行的情況，即此時最低鬆弛度的進程爲空。
//最低鬆弛度調度算法LLF
//正確的。。。#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#define queuesize 10
#define MAXTIME 150 //考慮前100ms時間
#define MINLLF 9999
#define PRO_LRU_T 0
//進程結構體
typedef struct process //進程
{
char pname[5]; //進程名
int deadtime; //週期
int servetime; //執行時間
//週期進程某一次執行到停止的剩餘需執行時間（考慮到搶佔），初始爲deadtime
int lefttime;
int cycle; //執行到的週期數
//進程最近一次的最遲開始執行時間，- currenttime 即爲鬆弛度
int latestarttime;
//進程下一次最早開始時間
int arivetime;
int k; //k=1，表示進程正在運行，否則爲0，表示進程不在執行期間
/*
若存在最小松弛度進程個數多於1個，
則採用最近最久未使用算法
採用一計數器LRU_t
*/
int LRU_t;
}process;
typedef struct sqqueue //循環隊列
{
process *data[queuesize];
int front,rear;
} sqqueue;
//初始化n個進程
void Initprocess(process *pro,int n)
{
int i;
process *p=pro;
for(i=0;i<n;i++)
{
*(p->pname)='\0';
p->deadtime=0;
p->servetime=0;
p->lefttime=0;
p->cycle=0;
p->latestarttime=0;
p->arivetime=0;
p->k=0;
p->LRU_t=0;
p++;
}
}
//初始化隊列（隊空）
void InitQueue(sqqueue *que)
{
que->front=que->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; //隊尾指針加1
printf("%s成功入隊!\n",pro->pname); //顯示進程入隊
}
}
//從當前隊列中找到最低鬆弛度的進程
process *llf(sqqueue *dui, int currenttime)
{
sqqueue *q1 = dui;
process *currentpro, *pro;
int minllf = MINLLF , llf;
int pro_LRU_t = PRO_LRU_T;
int front = q1->front, rear=q1->rear; //隊首元素？？
//將隊首進程賦給當前進程
currentpro = q1->data[front];
if( currenttime <= MAXTIME )
{
//求最短鬆弛度currentpro，如果隊列中只有一個進程
if( front==rear )
{
return currentpro;
printf("%dms時%s%d進程的鬆弛度爲：%d\n",currenttime,currentpro->pname,currentpro->cycle,llf);
}
//進程數目多於一個
else
{
/*
找當前時間下可以開始執行的進程中鬆弛度最小的，
賦給currentpro.
當最小松弛度的進程多於1個，
我們採用的是最後1個最小松弛度進程?
*/
do
{
if(front!=rear )
{
pro=q1->data[front];
if(pro->arivetime <= currenttime && currenttime<= MAXTIME)
{
//計算鬆弛度 = 週期*需執行的次數- （上一次）執行的時間 -當前時間
llf=(pro->deadtime)*(pro->cycle)- pro->lefttime - currenttime;
printf("%dms時%s%d進程的鬆弛度爲：%d\n",currenttime,pro->pname,pro->cycle,llf);
if(minllf>=llf) //比較得出最低鬆弛度
{
if( pro->LRU_t >= pro_LRU_t )
{
pro_LRU_t = pro->LRU_t ;
minllf=llf;
currentpro=pro;
}
}
}
front=(front+1)%queuesize;
}
else
break;
}while(front!=rear ); //檢測隊列是否遍歷完
}
}
return currentpro;
}
//尋找鬆弛度 <=0 的搶佔進程，替代當前最小松弛度進程
process *leastlaxityfirst(sqqueue *dui,int currenttime)
{
sqqueue *q1=dui;
process *pro=NULL, *nextpro;
int front= q1->front, rear= q1->rear ;
/*
當隊列不空，尋找當前時刻
是否有鬆弛度爲0（需搶佔進程）的進程
*/
while(front!=rear)
{
nextpro=q1->data[front];
/*
pro->latestarttime初始爲：
(pro->deadtime)*(pro->cycle) - pro->servetime;
pro->latestarttime - currenttime 即爲鬆弛度
pro->latestarttime - currenttime <= 0 ,
即鬆弛度 = 0，搶佔，跳出循環
*/
if( nextpro->latestarttime <= currenttime )
break;
else
front=(front+1)%queuesize;
}
//如果隊列空，返回pro
if(front==rear)
return pro;
//隊列不空，nextpro爲此時搶佔正在執行的進程的進程
else
return nextpro;
}
//從隊列中讀取進程的過程
void LLF_Process( sqqueue *dui )
{
int currenttime=0;
sqqueue *que=dui;
int front = que->front;
int rear = que->rear;
process *currentpro,*pro, *tmppro;
//currentpro爲當前時間隊列中鬆弛度最低的進程
currentpro=llf(que, currenttime);
//在MAXTIME時間內考慮
while(currenttime <= MAXTIME)
{
/*
最低鬆弛度進程爲空，
即爲當前時間沒有可運行的進程
*/
if(currentpro==NULL)
{
printf("%dms時無可運行進程!\n",currenttime);
break;
}
else
{
if((currentpro->arivetime <= currenttime ) )
{
if(currenttime==MAXTIME)
{
//當進程正在運行
if(currentpro->k == 1)
printf("%d ms: %s%d\n\n",currenttime,currentpro->pname,currentpro->cycle);
//當此時沒有進程運行
else
printf("\n=======執行只考慮前%dms，現時間已到%dms了！======\n",currenttime,currenttime);
break;
}
else if (currenttime!=MAXTIME)
{
if( currentpro->k== 0 )
{
printf("=> %dms時刻%s%d進程開始執行: %d - ",currenttime,currentpro->pname,currentpro->cycle,currenttime);
currentpro->k = 1; //表明進程開始運行
do
{
if(front!=rear )
{
pro=que->data[front];
if(pro != currentpro )
pro->LRU_t++;
front=(front+1)%queuesize;
}
else
break;
}while(front!=rear );
}
currenttime++; //當前時間增加
currentpro->lefttime--; //運行剩餘時間減少
//當剩餘運行時間等於0, 即當程序運行結束
if(currentpro->lefttime == 0)
{
if(currentpro->k==1)
{
printf("%d ms: %s%d\n\n",currenttime,currentpro->pname,currentpro->cycle);
currentpro->k=0; //表明進程開始進入不執行狀態
}
currentpro->cycle++;
currentpro->lefttime=currentpro->servetime;
currentpro->arivetime=(currentpro->deadtime)*(currentpro->cycle-1);
currentpro->latestarttime=(currentpro->deadtime)*(currentpro->cycle)-(currentpro->servetime);
currentpro=llf(que,currenttime);
}
//當進程未運行完畢。。。（可能被搶佔）
else
{
//pro爲搶佔當前正執行進程的進程
pro = leastlaxityfirst(que,currenttime);
if( pro!= NULL )
{
/*
如果當前存在搶佔進程，
即pro != currentpro，
則使currentpro進程進入不執行狀態
*/
if(pro != currentpro)
{
if( currentpro->k == 1 )
currentpro->k = 0;
printf("%d ms: %s%d\n\n",currenttime,currentpro->pname,currentpro->cycle);
printf("%dms時%s%d進程被進程%s%d進程搶佔！\n",currenttime,currentpro->pname,currentpro->cycle,pro->pname,pro->cycle);
}
/*
使currentpro爲鬆弛度最小的進程，
不論是否是搶佔程序。
*/
currentpro = pro;
}
}
}
}
//當進程下一次開始時間還沒到
else if( currentpro->arivetime >= currenttime )
{
if(currenttime==MAXTIME)
{
printf("\n=======執行只考慮前%dms，現時間已到%dms了！======\n",currenttime,currenttime);
break;
}
else
{
printf("第%dms時沒有進程到達!\n");
currenttime++;
currentpro=llf(que,currenttime);
}
}
}
}
}
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("請輸入週期進程有關的信息:\n");
while(flag)
{
pro=pro2+i;
printf("\n請輸入進程名（長度小於5）:");
gets(name);
strcpy(pro->pname,name);
printf("\n請輸入進程的週期:");
scanf("%d",&(pro->deadtime));
getchar();
printf("\n請輸入進程的執行時間:");
scanf("%d",&(pro->servetime)); getchar();
pro->lefttime = pro->servetime; //
pro->cycle=1; //初始時進程從第一週期開始執行
pro->latestarttime=(pro->deadtime)*(pro->cycle) - pro->servetime; //進程下一次最遲開始執行的時間
pro->arivetime=(pro->deadtime)*(pro->cycle-1); // 進程下一次開始的最早時間
pro->k = 0;
enterQueue(dui,pro); //進隊列
i++; //進程個數
printf("\n是否繼續進程信息的輸入(0:結束,1:繼續):");
scanf("%d",&flag); getchar();
}
dui2=dui;
front=dui2->front;
rear=dui2->rear;
while(front!=rear)
{
pro3=dui2->data[front];
ci=pro3->servetime+ci; //各進程執行的時間總和
pi=pro3->deadtime+pi; //各週期總和
front=(front+1)%queuesize;
}
//根據實時系統的要求：(ci/pi)<=1
if((ci/pi)<=1)
{
LLF_Process(dui);
printf("\n**********進程運行完畢!************\n");
printf("\n");
printf("是否要結束使用(Y/N)?");
scanf("%c",&ch); getchar();
if ('Y'== toupper(ch))
{
printf("\n 任意鍵結束! ");
scanf("%c",&ch2);
exit(0);
}
else
flag=1;
}
else
{
printf("所輸入的進程不滿足要求! ");
printf("\n是否重新輸入(Y/N):\n");
scanf("%c",&ch); getchar();
if ('N'==toupper(ch))
{
printf("請按任意鍵結束\n");
exit(0);
}
}
}
return 0;
}
1、不存在搶佔，但存在最低鬆弛度相同的進程的選擇
*******最低鬆弛調度**********
請輸入週期進程有關的信息:
請輸入進程名（長度小於5）:A
請輸入進程的週期:20
請輸入進程的執行時間:10
A成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):1
請輸入進程名（長度小於5）:B
請輸入進程的週期:50
請輸入進程的執行時間:10
B成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):1
請輸入進程名（長度小於5）:C
請輸入進程的週期:50
請輸入進程的執行時間:15
C成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):0
0ms時A1進程的鬆弛度爲：10
0ms時B1進程的鬆弛度爲：40
0ms時C1進程的鬆弛度爲：35
=> 0ms時刻A1進程開始執行: 0 - 10 ms: A1
10ms時B1進程的鬆弛度爲：30
10ms時C1進程的鬆弛度爲：25
=> 10ms時刻C1進程開始執行: 10 - 25 ms: C1
25ms時A2進程的鬆弛度爲：5
25ms時B1進程的鬆弛度爲：15
=> 25ms時刻A2進程開始執行: 25 - 35 ms: A2
35ms時B1進程的鬆弛度爲：5
=> 35ms時刻B1進程開始執行: 35 - 45 ms: B1
45ms時A3進程的鬆弛度爲：5
=> 45ms時刻A3進程開始執行: 45 - 55 ms: A3
55ms時B2進程的鬆弛度爲：35
55ms時C2進程的鬆弛度爲：30
=> 55ms時刻C2進程開始執行: 55 - 70 ms: C2
70ms時A4進程的鬆弛度爲：0
70ms時B2進程的鬆弛度爲：20
=> 70ms時刻A4進程開始執行: 70 - 80 ms: A4
80ms時A5進程的鬆弛度爲：10
80ms時B2進程的鬆弛度爲：10
=> 80ms時刻B2進程開始執行: 80 - 90 ms: B2
90ms時A5進程的鬆弛度爲：0
=> 90ms時刻A5進程開始執行: 90 - 100 ms: A5
100ms時A6進程的鬆弛度爲：10
100ms時B3進程的鬆弛度爲：40
100ms時C3進程的鬆弛度爲：35
=======執行只考慮前100ms，現時間已到100ms了！======
**********進程運行完畢!************
是否要結束使用(Y/N)?
2、存在搶佔的情況
*******最低鬆弛調度**********
請輸入週期進程有關的信息:
請輸入進程名（長度小於5）:A
請輸入進程的週期:20
請輸入進程的執行時間:10
A成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):1
請輸入進程名（長度小於5）:B
請輸入進程的週期:50
請輸入進程的執行時間:25
B成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):0
0ms時A1進程的鬆弛度爲：10
0ms時B1進程的鬆弛度爲：25
=> 0ms時刻A1進程開始執行: 0 - 10 ms: A1
10ms時B1進程的鬆弛度爲：15
=> 10ms時刻B1進程開始執行: 10 - 30 ms: B1
30ms時B1進程被進程A2進程搶佔！
=> 30ms時刻A2進程開始執行: 30 - 40 ms: A2
40ms時A3進程的鬆弛度爲：10
40ms時B1進程的鬆弛度爲：5
=> 40ms時刻B1進程開始執行: 40 - 45 ms: B1
45ms時A3進程的鬆弛度爲：5
=> 45ms時刻A3進程開始執行: 45 - 55 ms: A3
55ms時B2進程的鬆弛度爲：20
=> 55ms時刻B2進程開始執行: 55 - 70 ms: B2
70ms時B2進程被進程A4進程搶佔！
=> 70ms時刻A4進程開始執行: 70 - 80 ms: A4
80ms時A5進程的鬆弛度爲：10
80ms時B2進程的鬆弛度爲：10
=> 80ms時刻B2進程開始執行: 80 - 90 ms: B2
90ms時A5進程的鬆弛度爲：0
=> 90ms時刻A5進程開始執行: 90 - 100 ms: A5
100ms時A6進程的鬆弛度爲：10
100ms時B3進程的鬆弛度爲：25
=======執行只考慮前100ms，現時間已到100ms了！======
**********進程運行完畢!************
是否要結束使用(Y/N)?
3、在截止時間時，某一進程還沒有運行完
*******最低鬆弛調度**********
請輸入週期進程有關的信息:
請輸入進程名（長度小於5）:A
請輸入進程的週期:20
請輸入進程的執行時間:10
A成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):1
請輸入進程名（長度小於5）:B
請輸入進程的週期:50
請輸入進程的執行時間:10
B成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):1
請輸入進程名（長度小於5）:C
請輸入進程的週期:50
請輸入進程的執行時間:15
C成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):0
0ms時A1進程的鬆弛度爲：10
0ms時B1進程的鬆弛度爲：40
0ms時C1進程的鬆弛度爲：35
=> 0ms時刻A1進程開始執行: 0 - 10 ms: A1
10ms時B1進程的鬆弛度爲：30
10ms時C1進程的鬆弛度爲：25
=> 10ms時刻C1進程開始執行: 10 - 25 ms: C1
25ms時A2進程的鬆弛度爲：5
25ms時B1進程的鬆弛度爲：15
=> 25ms時刻A2進程開始執行: 25 - 35 ms: A2
35ms時B1進程的鬆弛度爲：5
=> 35ms時刻B1進程開始執行: 35 - 45 ms: B1
45ms時A3進程的鬆弛度爲：5
=> 45ms時刻A3進程開始執行: 45 - 55 ms: A3
55ms時B2進程的鬆弛度爲：35
55ms時C2進程的鬆弛度爲：30
=> 55ms時刻C2進程開始執行: 55 - 70 ms: C2
70ms時A4進程的鬆弛度爲：0
70ms時B2進程的鬆弛度爲：20
=> 70ms時刻A4進程開始執行: 70 - 80 ms: A4
80ms時A5進程的鬆弛度爲：10
80ms時B2進程的鬆弛度爲：10
=> 80ms時刻B2進程開始執行: 80 - 90 ms: B2
90ms時A5進程的鬆弛度爲：0
=> 90ms時刻A5進程開始執行: 90 - 100 ms: A5
100ms時A6進程的鬆弛度爲：10
100ms時B3進程的鬆弛度爲：40
100ms時C3進程的鬆弛度爲：35
=> 100ms時刻A6進程開始執行: 100 - 110 ms: A6
110ms時B3進程的鬆弛度爲：30
110ms時C3進程的鬆弛度爲：25
=> 110ms時刻C3進程開始執行: 110 - 125 ms: C3
125ms時A7進程的鬆弛度爲：5
125ms時B3進程的鬆弛度爲：15
=> 125ms時刻A7進程開始執行: 125 - 135 ms: A7
135ms時B3進程的鬆弛度爲：5
=> 135ms時刻B3進程開始執行: 135 - 145 ms: B3
145ms時A8進程的鬆弛度爲：5
=> 145ms時刻A8進程開始執行: 145 - 150 ms: A8
=======執行只考慮前150ms，現時間已到150ms了！======
**********進程運行完畢!************
是否要結束使用(Y/N)?
4、存在某一時刻沒有進程運行
*******最低鬆弛調度**********
請輸入週期進程有關的信息:
請輸入進程名（長度小於5）:A
請輸入進程的週期:20
請輸入進程的執行時間:10
A成功入隊!
是否繼續進程信息的輸入(0:結束,1:繼續):0
0ms時A1進程的鬆弛度爲：10
=> 0ms時刻A1進程開始執行: 0 - 10 ms: A1
第10ms時沒有進程到達!
第11ms時沒有進程到達!
第12ms時沒有進程到達!
第13ms時沒有進程到達!
第14ms時沒有進程到達!
第15ms時沒有進程到達!
第16ms時沒有進程到達!
第17ms時沒有進程到達!
第18ms時沒有進程到達!
第19ms時沒有進程到達!
20ms時A2進程的鬆弛度爲：10
=> 20ms時刻A2進程開始執行: 20 - 30 ms: A2
第30ms時沒有進程到達!
第31ms時沒有進程到達!
第32ms時沒有進程到達!
第33ms時沒有進程到達!
第34ms時沒有進程到達!
第35ms時沒有進程到達!
第36ms時沒有進程到達!
第37ms時沒有進程到達!
第38ms時沒有進程到達!
第39ms時沒有進程到達!
40ms時A3進程的鬆弛度爲：10
=> 40ms時刻A3進程開始執行: 40 - 50 ms: A3
第50ms時沒有進程到達!
第51ms時沒有進程到達!
第52ms時沒有進程到達!
第53ms時沒有進程到達!
第54ms時沒有進程到達!
第55ms時沒有進程到達!
第56ms時沒有進程到達!
第57ms時沒有進程到達!
第58ms時沒有進程到達!
第59ms時沒有進程到達!
60ms時A4進程的鬆弛度爲：10
=> 60ms時刻A4進程開始執行: 60 - 70 ms: A4
第70ms時沒有進程到達!
第71ms時沒有進程到達!
第72ms時沒有進程到達!
第73ms時沒有進程到達!
第74ms時沒有進程到達!
第75ms時沒有進程到達!
第76ms時沒有進程到達!
第77ms時沒有進程到達!
第78ms時沒有進程到達!
第79ms時沒有進程到達!
80ms時A5進程的鬆弛度爲：10
=======執行只考慮前80ms，現時間已到80ms了！======
**********進程運行完畢!************
是否要結束使用(Y/N)?