操作系統(tǒng)課程設計

資源下載：https://download.csdn.net/download/fufuyfu/85811450

一、課程設計目的

操作系統(tǒng)是計算機系統(tǒng)配置的基本軟件之一。它在整個計算機系統(tǒng)軟件中占有中心地位。其作用是對計算機系統(tǒng)進行統(tǒng)一的調(diào)度和管理，提供各種強有力的系統(tǒng)服務，為用戶創(chuàng)造既靈活又方便的使用環(huán)境。本課程是計算機及應用專業(yè)的一門專業(yè)主干課和必修課。
通過課程設計，使學生掌握操作系統(tǒng)的基本概念、設計原理及實施技術(shù),具有分析操作系統(tǒng)和設計、實現(xiàn)、開發(fā)實際操作系統(tǒng)的能力。

二、課程設計內(nèi)容和要求

1、提交一批作業(yè)（>=10），按先來先服務選擇一部分作業(yè)（最多5個）進入內(nèi)存
2、為每個作業(yè)創(chuàng)建一個進程，并分配內(nèi)存（用戶內(nèi)存：0—1024K，采用可變連續(xù)分配方式）
3、進程調(diào)度功能（時間片輪轉(zhuǎn)）
4、隨機阻塞進程，并在一段時間后喚醒進程（選做）
5、顯示相關(guān)信息：后備作業(yè)隊列、內(nèi)存分配情況、進程信息、完成作業(yè)情況
6、這些功能要有機地連接起來

三、軟、硬件環(huán)境

軟件：Window10，Dev-C++
硬件：CPU：Intel? Core? i5-8265U CPU @ 1.60GHz 1.80 GHz
RAM：8.00GB

四、設計步驟及實現(xiàn)

1、課程設計題目分析

本次課程設計將作業(yè)調(diào)度（先來先服務算法）、動態(tài)內(nèi)存管理（首次適應算法）、進程調(diào)度（時間片輪轉(zhuǎn)調(diào)度算法）、進程阻塞（隨機阻塞進程和喚醒進程）等功能有機結(jié)合。首先，需要按照用戶輸入的作業(yè)數(shù)隨機初始化相應的作業(yè)并構(gòu)成后備作業(yè)隊列，同時初始化內(nèi)存分區(qū)表以及進程隊列，即后備作業(yè)隊列模擬外存，進程隊列模擬內(nèi)存，內(nèi)存分區(qū)表用于內(nèi)存管理，然后使用先來先服務（FCFS）進行作業(yè)調(diào)度，即模擬將作業(yè)從外存調(diào)入到內(nèi)存，再使用時間片輪轉(zhuǎn)調(diào)度算法（RR）進行進程調(diào)度。其中，最多只能有5個作業(yè)同時進入內(nèi)存，即內(nèi)存中處于運行、等待、阻塞的進程數(shù)之和最多為5個。因此在本次課程設計中我用一個全局變量記錄當前進程數(shù)，當前進程數(shù)小于5時，從后備作業(yè)隊列中調(diào)入已到達并且未完成作業(yè)并為該作業(yè)創(chuàng)建進程同時使用首次適應算法（FF）為其分配內(nèi)存，再進行進程調(diào)度，并在進程調(diào)度的過程中，隨機阻塞進程，并在一定的時間后喚醒進程。本次課程設計中我用一個指針記錄當前執(zhí)行的進程，每一次從該進程開始找進程為wait并執(zhí)行一定時間。若當前進程完成（即包含作業(yè)已完成）時，釋放該進程占用的內(nèi)存并將該已完成的作業(yè)調(diào)到后備作業(yè)隊列的末尾，即已完成作業(yè)從內(nèi)存調(diào)出。整個進程調(diào)度的過程直到后備作業(yè)隊列的第一個作業(yè)為完成狀態(tài)以及進程隊列為空則結(jié)束。

2、算法流程圖

3、程序代碼

3.1 頭文件及數(shù)據(jù)結(jié)構(gòu)

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h>#define TIME_SLICE 2 #define Max_Memory 1024 #define Block_Time 8// 進程、作業(yè)狀態(tài)：就緒 等待 阻塞 完成 enum status{status_wait = 'W',status_run = 'R',status_block = 'B',status_finish = 'F' };// 進程控制塊結(jié)構(gòu)體 typedef struct PCB{ // 進程名char process_name[5]; // 到達時間int arrive_time;// 仍需時間int need_time;// 進程狀態(tài)：運行、就緒、阻塞、完成// 但完成狀態(tài)不顯示在進程隊列中，完成則調(diào)出內(nèi)存 char status;// 進程阻塞時長int block_time; // 占用內(nèi)存起址 int begin;// 占用內(nèi)存大小 int size;// 占用作業(yè) char task_name[5];// 后向指針PCB *next; }PCB; // 內(nèi)存塊結(jié)構(gòu)體 typedef struct Node{ // 分區(qū)起址 int begin; // 分區(qū)大小 int size; // 分區(qū)狀態(tài)：Busy(1)或Free(0) int status; // 占用進程 char process_name[5]; // 后向指針Node *next; }Node;// 作業(yè)結(jié)構(gòu)體 typedef struct Task{// 作業(yè)名char task_name[5]; // 到達時間int arrive_time;// 所需時間int need_time;// 所需內(nèi)存 int size;// 作業(yè)狀態(tài)：等待、完成 char status; // 后向指針Task *next; }Task;// 進程調(diào)度總時間 int Total_time = 0; // 記錄當前執(zhí)行進程的位置 PCB *runIndex = NULL; // 記錄當前進程隊列個數(shù) int sum = 0; // 記錄已經(jīng)生成的進程數(shù) int number = 0;

3.2 函數(shù)聲明及主函數(shù)

// 函數(shù)聲明 // 初始化內(nèi)存分區(qū) void initNode(Node *node); // 首次適應算法分配內(nèi)存 bool first_fit(Node *node_list,PCB *new_process); // 隨機產(chǎn)生一批作業(yè)(>=10個) void create_task(Task *task_list); // 按到達時間插入新作業(yè) void insert_task(Task *task_list,Task *new_task); // 將已完成作業(yè)調(diào)整到作業(yè)隊列尾部 void finish_task(Task *task_list,PCB *finish_process); // 先來先服務選擇作業(yè) void change_task(Node *node_list,Task *task_list,PCB *process_list); // 創(chuàng)建新進程 bool create_process(PCB *process_list,Task *move_task,Node *node_list); // 按起始地址插入新進程 void insert_process(PCB *process_list,PCB *new_process); // 隨機阻塞進程 void block_process(PCB *process_list); // 喚醒進程 void notify_process(PCB *process_list); // 時間片輪轉(zhuǎn)調(diào)度算法 void round_robin(Node *node_list,Task *tasl_list,PCB *process_list); // 展示：內(nèi)存分區(qū)表、內(nèi)存分配情況 void show_node(Node *node_list); // 展示：后備作業(yè)隊列、作業(yè)完成情況 void show_task(Task *task_list); // 展示：進程運行情況、作業(yè)完成情況 void show_process(PCB *process_list);// 主函數(shù) int main(){srand(time(NULL));// 創(chuàng)建內(nèi)存分區(qū)鏈表Node *node_list = (Node*)malloc(sizeof(Node));if(node_list == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }else{node_list->next = NULL;}initNode(node_list); // 創(chuàng)建后備作業(yè)隊列 Task *task_list = (Task*)malloc(sizeof(Task));if(task_list == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }else{task_list->next = NULL;}create_task(task_list);// 創(chuàng)建空進程隊列PCB *process_list = (PCB*)malloc(sizeof(PCB));if(process_list == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }else{process_list->next = NULL;}printf("初始狀態(tài)：\n"); show_node(node_list);show_task(task_list);show_process(process_list);// 調(diào)用時間片輪轉(zhuǎn)調(diào)度算法 round_robin(node_list,task_list,process_list); }

3.3 初始化內(nèi)存分區(qū)

// 初始化內(nèi)存分區(qū) void initNode(Node *node){Node *new_node = (Node*)malloc(sizeof(Node));if(new_node == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }// 分區(qū)起址new_node->begin = 0;// 分區(qū)大小 new_node->size = Max_Memory;// 分區(qū)狀態(tài)：0代表空閑，1代表占用 new_node->status = 0;// 進程名sprintf(new_node->process_name,"%s","無"); // 后向指針 new_node->next = NULL;// 將該初始化分區(qū)放入分區(qū)鏈表 node->next = new_node; }

3.4 首次適應算法分配內(nèi)存

// 首次適應算法分配內(nèi)存 bool first_fit(Node *node_list,PCB *new_process){ Node *move = node_list->next;// 空閑內(nèi)存分區(qū)鏈不為空 while(move != NULL){// 空閑的空間if(move->status == 0){ // 剩余空間大于作業(yè)需要的內(nèi)存空間，可分配 if(move->size > new_process->size){ // 分配后剩余的空間 Node *p = (Node*)malloc(sizeof(Node));p->begin = move->begin + new_process->size;p->size = move->size - new_process->size;p->status = 0;sprintf(p->process_name,"%s","無"); // 分配給進程的空間move->size = new_process->size;move->status = 1;sprintf(move->process_name,"%s",new_process->process_name);// 改變節(jié)點的連接 p->next = move->next; move->next = p;break; }else if(move->size == new_process->size){ // 空閑空間和作業(yè)需要的內(nèi)存空間大小相等時，可分配 move->status = 1;sprintf(move->process_name,"%s",new_process->process_name);break;} }// 已到空閑內(nèi)存分區(qū)鏈末尾 if(move->next == NULL){printf("內(nèi)存分配失敗，沒有足夠大的內(nèi)存分配給該進程！\n");return false;}move = move->next;}new_process->begin = move->begin;show_node(node_list);return true; }

3.5 回收內(nèi)存并將其中作業(yè)調(diào)整到后備作業(yè)隊列

// 回收內(nèi)存并將其中作業(yè)調(diào)整到后備作業(yè)隊列 void recycle(Node *node_list,PCB *finish_process){Node *move = node_list->next; while(true){// 當進程隊列的第一個進程占用內(nèi)存需釋放時 if(strcmp(move->process_name,finish_process->process_name) == 0){ move->status = 0; sprintf(move->process_name,"%s","無");break;}else if(move->status == 0 && strcmp(move->next->process_name,finish_process->process_name) == 0){// 當move指向需釋放空間的前驅(qū)結(jié)點，需釋放空間的上一塊空間空閑時// 合并需釋放空間上一塊空間和需釋放空間 move->size = move->size + move->next->size;Node *q = move->next;move->next = move->next->next;// 釋放內(nèi)存 free(q);break;}else if(strcmp(move->next->process_name,finish_process->process_name) == 0){ // 需釋放空間的上一塊空間忙碌時 // move指向當前釋放的內(nèi)存空間 move = move->next; move->status = 0; sprintf(move->process_name,"%s","無"); break;}else if(move->next == NULL){ // 已走到鏈表末尾，此時表明進程名都不匹配 printf("此進程不存在！\n");break;}move = move->next;}// 需釋放空間的下一個空間空閑時 if(move->next != NULL && move->next->status == 0){ move->size = move->size + move->next->size;Node *q = move->next;move->next = move->next->next;free(q);} }

3.6 隨機產(chǎn)生一批作業(yè)（>=10）

// 隨機產(chǎn)生一批作業(yè)(>=10) void create_task(Task *task_list){printf("\n請輸入產(chǎn)生的作業(yè)數(shù)(>=10)：");int number; scanf("%d",&number);printf("\n");int i = 1;// 循環(huán)創(chuàng)建后備作業(yè)隊列 while(i <= number){// 創(chuàng)建新作業(yè) Task *new_task = (Task*)malloc(sizeof(Task)); if(new_task == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }// 作業(yè)名sprintf(new_task->task_name,"%s%d","T",i);// 到達時間(0~8)if(task_list->next == NULL){new_task->arrive_time = 0;}else{new_task->arrive_time = rand()%19;}// 服務時間(1~10) new_task->need_time = rand()%12+1;// 所需內(nèi)存(31~200)new_task->size = rand()%(Max_Memory/5)+31;// 作業(yè)狀態(tài)new_task->status = status_wait; // 后向指針new_task->next = NULL; // 創(chuàng)建下一作業(yè)++i;// 將新作業(yè)插入后備作業(yè)隊列insert_task(task_list,new_task); } }

3.7 按到達時間插入新作業(yè)

// 按到達時間插入新作業(yè) void insert_task(Task *task_list,Task *new_task){int arrive_time = new_task->arrive_time;Task *move = task_list;while(move->next != NULL){if(move->next->arrive_time > arrive_time){new_task->next = move->next;move->next = new_task;return;}move = move->next;}move->next = new_task; }

3.8 將已完成作業(yè)調(diào)整到作業(yè)隊列尾部

// 將已完成作業(yè)調(diào)整到作業(yè)隊列尾部 void finish_task(Task *task_list,PCB *finish_process){Task *finish_task = (Task*)malloc(sizeof(Task));if(finish_task == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }sprintf(finish_task->task_name,"%s",finish_process->task_name);finish_task->arrive_time = finish_process->arrive_time;finish_task->need_time = finish_process->need_time;finish_task->size = finish_process->size;finish_task->status = finish_process->status;finish_task->next = NULL; Task *move = task_list;while(move->next != NULL){move = move->next;}move->next = finish_task;show_task(task_list); }

3.9 先來先服務選擇作業(yè)

// 先來先服務選擇作業(yè) void change_task(Node *node_list,Task *task_list,PCB *process_list){/*由于進程最多5個并發(fā)，即等待、阻塞、運行的進程數(shù)最多為5個所以從作業(yè)隊列中選擇作業(yè)不能使進程超過5個，而且要考慮作業(yè)是否到達 */// 選擇作業(yè)Task *move = task_list->next;while(sum < 5 && move != NULL && move->status != status_finish && move->arrive_time <= Total_time){// 先保存要調(diào)入內(nèi)存的作業(yè) Task *move_task = move;// 為該作業(yè)創(chuàng)建進程if(create_process(process_list,move_task,node_list)){// 分配內(nèi)存成功 sum++;// 剔除作業(yè)Task *p = task_list;while(p->next != move){p = p->next;} p->next = move->next;move = p->next;}else{move = move->next;} } }

3.10 為新調(diào)入內(nèi)存的作業(yè)創(chuàng)建新進程

// 為新調(diào)入內(nèi)存的作業(yè)創(chuàng)建新進程 bool create_process(PCB *process_list,Task *move_task,Node *node_list){PCB *new_process = (PCB*)malloc(sizeof(PCB));if(new_process == NULL){printf("動態(tài)內(nèi)存分配失敗！"); }// 進程名 sprintf(new_process->process_name,"%s%d","P",++number);// 到達時間new_process->arrive_time = move_task->arrive_time; // 仍需時間new_process->need_time = move_task->need_time;// 進程狀態(tài)new_process->status = move_task->status;// 阻塞時長new_process->block_time = 0; // 占用內(nèi)存起址 new_process->begin = 0;// 占用內(nèi)存大小 new_process->size = move_task->size;// 占用作業(yè) sprintf(new_process->task_name,"%s",move_task->task_name);// 后向指針new_process->next = NULL; // 為新進程分配內(nèi)存 if(!first_fit(node_list,new_process)){free(new_process); return false;}// 將新進程放入進程隊列insert_process(process_list,new_process);return true; }

3.11 按起始地址插入新進程

// 按起始地址插入新進程 void insert_process(PCB *process_list,PCB *new_process){int begin = new_process->begin;PCB *move = process_list;while(move->next != NULL){if(move->next->begin > begin){new_process->next = move->next;move->next = new_process;return;}move = move->next;}move->next = new_process;show_process(process_list); }

3.12 隨機阻塞進程

// 隨機阻塞進程 void block_process(PCB *process_list){// 隨機生成阻塞進程名 int block_id = rand()%number+1;char block_pro[5];sprintf(block_pro,"%s%d","P",block_id);PCB *move = process_list->next;while(move != NULL){if(strcmp(move->process_name,block_pro) == 0){// 更新進程狀態(tài) move->status = status_block;// 將阻塞時長置0 move->block_time = 0;printf("阻塞進程：%s\n",move->process_name);return;}move = move->next;} }

3.13 喚醒進程

// 喚醒進程 void notify_process(PCB *process_list){PCB *move = process_list->next;while(move != NULL){if(move->block_time >= Block_Time){// 更新進程狀態(tài) move->status = status_wait;// 將阻塞時長置0 move->block_time = 0;printf("喚醒進程：%s\n",move->process_name);}move = move->next;} }

3.14 時間片輪轉(zhuǎn)調(diào)度算法

// 時間片輪轉(zhuǎn)調(diào)度算法 void round_robin(Node *node_list,Task *task_list,PCB *process_list){/*用一個全局變量記錄當前進程數(shù)，當前進程數(shù)小于5時，從作業(yè)隊列中調(diào)入已到達作業(yè)并為作業(yè)創(chuàng)建進程分配內(nèi)存用一個指針記錄當前執(zhí)行的進程，每一次從該進程開始找進程為wait并執(zhí)行一個時間片當一個進程完成時，釋放該進程占用的內(nèi)存并將該已完成的作業(yè)調(diào)到后備作業(yè)隊列的末尾 整個調(diào)度過程直到后備作業(yè)隊列的第一個作業(yè)為完成狀態(tài)以及進程隊列為空則結(jié)束在進程調(diào)度的過程中，隨機阻塞進程：一定的時間后喚醒進程 */// 記錄當前執(zhí)行進程的位置，初始指向進程隊列的第一個進程 runIndex = process_list->next; while (sum != 0 || task_list->next->status != status_finish) {// 保存舊進程數(shù) int old_sum = sum;// 當前進程數(shù)小于5并且仍然有作業(yè)未完成，從后備隊列選擇作業(yè)if(sum < 5 && task_list->next != NULL && task_list->next->status != status_finish){change_task(node_list,task_list,process_list); }// 隨機阻塞進程 block_process(process_list);// 喚醒進程notify_process(process_list); // 剛好runIndex指向NULL且當前進程數(shù)增加 if(runIndex == NULL && old_sum < sum){// 找出之前進程的最后一個 int move_sum = 0;PCB *move = process_list; while(move_sum < old_sum){move_sum++;move = move->next;} // runIndex指向新加入的進程 runIndex = move->next;}else if(runIndex == NULL){// 當runIndex指向NULL且當前進程數(shù)未增加// runIndex重新指向進程隊列的第一個進程 runIndex = process_list->next;} // 經(jīng)過以上處理runIndex仍然為NULL，則當前無進程無作業(yè)到達 if(runIndex == NULL){printf("當前無進程且無作業(yè)到達！\n");printf("等待作業(yè)到達。。。。。。\n");printf("等待時長：%d\n",task_list->next->arrive_time - Total_time);Total_time += task_list->next->arrive_time - Total_time;printf("進程調(diào)度總時間：%d\n",Total_time);continue; }// 循環(huán)遍歷進程隊列，找到進程狀態(tài)為wait的進程并執(zhí)行PCB *memoryIndex = runIndex;while(runIndex->status != status_wait){runIndex = runIndex->next; // runIndex走到進程隊列末尾 if(runIndex == NULL){runIndex = process_list->next;}// runIndex循環(huán)一遍后仍找不到狀態(tài)為wait的進程 if(runIndex == memoryIndex){show_process(process_list);// 表示所有進程都阻塞// 找出距離阻塞進程被喚醒最近的進程，等待該進程被喚醒int notify_time = Block_Time - process_list->next->block_time;PCB *move = process_list->next;while(move != NULL){// 如果有距離阻塞進程被喚醒更近的進程 if(Block_Time - move->block_time < notify_time){// 更新喚醒時長notify_time = Block_Time - move->block_time; }move = move->next;} printf("當前進程全部阻塞，等待進程被喚醒！\n");printf("等待時長：%d\n",notify_time);// 此時已找出距離阻塞進程被喚醒最近時長move = process_list->next;while(move != NULL){// 等待進程被喚醒 // 更新所有進程的阻塞時長move->block_time += notify_time; move = move->next;}// 更新進程調(diào)度總時間 Total_time += notify_time; show_process(process_list); // 喚醒進程 notify_process(process_list);show_process(process_list); // 重新進行進程調(diào)度 printf("進程調(diào)度總時間：%d\n",Total_time);continue;}}// 執(zhí)行當前進程 runIndex->status = status_run; show_process(process_list);// 判斷該進程是否能完成 if (runIndex->need_time-TIME_SLICE > 0) {// 進程執(zhí)行一個時間片后無法完成 // 更新進程調(diào)度總時間 Total_time += TIME_SLICE;// 更新進程仍需時間 runIndex->need_time -= TIME_SLICE;// 更改進程狀態(tài)runIndex->status = status_wait; // 指向下一進程 runIndex = runIndex->next; // 更新阻塞時長PCB *p = process_list->next;while(p != NULL){if(p->status == status_block){p->block_time += TIME_SLICE;}p = p->next;} }else{// 進程可以完成// 更新阻塞時長PCB *p = process_list->next;while(p != NULL){if(p->status == status_block){p->block_time += runIndex->need_time;}p = p->next;}// 更新進程調(diào)度總時間 Total_time += runIndex->need_time;// 更新進程仍需時間 runIndex->need_time = 0;runIndex->status = status_finish;show_process(process_list);// 移除該進程同時釋放內(nèi)存并將其中作業(yè)調(diào)整到后備作業(yè)隊列PCB *finish_process = runIndex;PCB *move = process_list;while(move->next != runIndex){move = move->next;}// 移除進程 move->next = runIndex->next;// 指向下一進程 runIndex = move->next; // 將其中作業(yè)調(diào)整到后備作業(yè)隊列并釋放內(nèi)存finish_task(task_list,finish_process); recycle(node_list,finish_process); free(finish_process);sum--;} show_node(node_list);show_task(task_list);show_process(process_list);printf("進程調(diào)度總時間：%d\n",Total_time);} }

3.15 展示函數(shù)

// 展示：內(nèi)存分區(qū)表、內(nèi)存分配情況 void show_node(Node *node_list){Node *move = node_list->next;printf("************************************************************************************\n");printf(" 內(nèi)存分區(qū)表 \n");printf("－－－－－－－－－－－－－－－－－－－－－\n");printf("|起始地址 分區(qū)大小 占用進程 分區(qū)狀態(tài)|\n");while(move != NULL){if(move->status == 0){printf("| %d\t %d\t %s\t Free |\n",move->begin,move->size,move->process_name,move->status);}else{printf("| %d\t %d\t %s\t Busy |\n",move->begin,move->size,move->process_name,move->status);}move = move->next;}printf("－－－－－－－－－－－－－－－－－－－－－\n"); } // 展示：后備作業(yè)隊列、作業(yè)完成情況 void show_task(Task *task_list){Task *move = task_list->next;printf(" 后備作業(yè)隊列 \n");printf("～～～～～～～～～～～～～～～～～～～～～～～～～～\n");printf("|作業(yè)名 到達時間 所需時間 所需內(nèi)存 作業(yè)狀態(tài)|\n");while(move != NULL){printf("| %s\t %d\t %d\t %d\t %c |\n",move->task_name,move->arrive_time,move->need_time,move->size,move->status);move = move->next;}printf("～～～～～～～～～～～～～～～～～～～～～～～～～～\n"); }// 展示：進程運行情況、作業(yè)完成情況 void show_process(PCB *process_list){PCB *move = process_list->next;printf(" 當前各進程PCB信息 \n");printf("﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀\n");printf("|進程名 到達時間 仍需時間 進程狀態(tài) 阻塞時長 內(nèi)存起址 內(nèi)存大小 占用作業(yè)|\n");while(move != NULL){printf("| %s\t %d\t %d\t %c\t %d\t %d\t %d\t %s |\n",move->process_name,move->arrive_time,move->need_time,move->status,move->block_time,move->begin,move->size,move->task_name);move = move->next;}printf("﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀﹀\n"); }

4、運行結(jié)果及分析（由于運行結(jié)果過多，此處僅展示關(guān)鍵部分）

用戶向系統(tǒng)提交需隨機產(chǎn)生10個作業(yè)，此時為進程調(diào)度的初始狀態(tài)。內(nèi)存尚為進行分配，暫無進程信息，內(nèi)存初始化大小為1024K，隨機生成的10個作業(yè)已按到達時間排序成后備作業(yè)序列（外存）。

此時已從外存中將作業(yè)T1和T9調(diào)入內(nèi)存，分配所需內(nèi)存并創(chuàng)建進程P1和P2，同時此時隨機阻塞了進程P2，P1進程運行一個時間片（2），同時P2進程更新阻塞時長，當P2進程阻塞時長達到一定值時，會被喚醒。

此時內(nèi)存中已有P1~P5共5個進程，后備作業(yè)隊列中仍未有作業(yè)完成，當前進程調(diào)度總時間為20，此時阻塞進程P5，即進程P5的阻塞時長置0，喚醒進程P1，即進程P1的阻塞時長置0的同時更改進程狀態(tài)為等待（W），又剛好排到進程P1執(zhí)行，更改進程狀態(tài)為運行（R），并在此過程中，該進程所包含的作業(yè)T1可完成，所以完成作業(yè)T1后，將該作業(yè)調(diào)整到后備作業(yè)隊列的末尾并將其對應進程P1所占用的內(nèi)存釋放。

此時當前進程僅剩進程P6，當進程P6被阻塞時，會就此等待進程P6的阻塞時長到達特定值后喚醒并再次進行進程調(diào)度，雖然進程P6可能再次被阻塞，但最終還是會完成進程P6。此邊界情況如進程隊列中所有進程同時阻塞，此時會等待進程中距離喚醒時長最短的進程被喚醒并再次進行進程調(diào)度。雖然進程可能再次被阻塞，但最終還是會完成該進程。可防止出現(xiàn)因所有進程均阻塞而進入死循環(huán)，使程序更具有穩(wěn)定性。

此時最后一個進程P6中所包含的作業(yè)T7完成，進程調(diào)度總時間為90，此時進程隊列已為空，內(nèi)存分區(qū)表回到初始狀態(tài)，后備作業(yè)隊列中所有的作業(yè)狀態(tài)均顯示已完成，表示此次整個進程調(diào)度的過程已結(jié)束。

五、心得體會

我在完成此次課程設計之前已自主完成了進程調(diào)度、銀行家算法、內(nèi)存管理、磁盤調(diào)度四個實驗，因此在完成課程設計的過程中沒有出現(xiàn)什么原則上的錯誤，但還是會出現(xiàn)一些小紕漏，如在創(chuàng)建進程時內(nèi)存申請不成功便將作業(yè)從后備作業(yè)隊列中剔除，導致程序運行結(jié)果混亂。因此我在剔除作業(yè)前先嘗試為進程申請內(nèi)存，若申請成功，則返回true告知可以從后備作業(yè)隊列中剔除作業(yè)，這樣就不會出現(xiàn)差錯了。在本次課程設計中，與以往進程調(diào)度實驗不同的是要求隨機阻塞進程，我使用隨機生成進程號，并判斷當前進程隊列中是否存在匹配進程，有則阻塞，無則放棄。同時在進程結(jié)構(gòu)體中設置阻塞時長字段，在進程調(diào)度過程中，更新被阻塞進程的阻塞時長，當該阻塞時長達到特定值時，對相應進程進行喚醒，較好的解決的阻塞與喚醒進程的要求。
本次課程設計的難點在于如何將作業(yè)調(diào)度、進程調(diào)度、內(nèi)存分配管理等有機地結(jié)合來。雖然該過程難度較高，但通過親手編寫代碼，一步一步地分析與調(diào)試，最后完成需求功能，滿足了內(nèi)心大大的成就感，激起我對操作系統(tǒng)學習的興趣，同時也在一定程度加深了我對操作系統(tǒng)的部分內(nèi)部運行原理的理解，更進一步掌握了操作系統(tǒng)的設計、分析、實現(xiàn)的流程。總之，收獲良多。

總結(jié)

以上是生活随笔為你收集整理的操作系统课程设计（作业调度、内存管理、进程调度、进程阻塞等）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。