如何進行windows操作系統動態分區分配方式原理詳解與代碼測試

這期內容當中小編將會給大家帶來有關如何進行windows操作系統動態分區分配方式原理詳解與代碼測試，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

操作系統的動態分區分配方式是操作系統中存儲器管理中連續分配方式的其中一種，另外三種分配方式分別是：單一連續分配、固定分區分配、動態分區分配、動態重定位分區分配。連續分配方式，是指為一個用戶程序分配一個連續的內存空間。

內容：

(1)．用C或其他語言分別實現采用首次適應算法和最佳適應算法的動態分區分配過程和回收過程。

(2)．設置初始狀態，每次分配和回收后顯示出空閑內存分區鏈的情況。

原理：

    分區分配，首次適應算法，最佳適應算法等。 

源代碼（只進行了小規模的數據測驗）：

#include<stdio.h>
#include<stdlib.h>
#define SIZE 640          // 內存初始大小
#define MINSIZE 5         // 碎片最小值
enum STATE { Free, Busy };

struct subAreaNode {
    intaddr;             // 起始地址
    intsize;             // 分區大小
    inttaskId;            //作業號
    STATEstate;           //分區狀態
   subAreaNode *pre;      // 分區前向指針
   subAreaNode *nxt;      // 分區后向指針
}subHead;// 初始化空閑分區鏈void intSubArea()
{
    //分配初始分區內存
   subAreaNode *fir = (subAreaNode*)malloc(sizeof(subAreaNode));
    //給首個分區賦值
   fir->addr   = 0;
   fir->size   = SIZE;
   fir->state  = Free;
   fir->taskId = -1;
   fir->pre    =&subHead;
   fir->nxt    =NULL;
    //初始化分區頭部信息
   subHead.pre = NULL;
   subHead.nxt = fir;
}// 首次適應算法int firstFit(int taskId, int size)
{
   subAreaNode *p = subHead.nxt;
    while(p!= NULL)
   {
       if(p->state ==Free && p->size>= size) {
          // 找到要分配的空閑分區
          if(p->size - size<= MINSIZE) {
              //整塊分配
             p->state = Busy;
             p->taskId = taskId;
          } else {
              //分配大小為size的區間
             subAreaNode *node = (subAreaNode*)malloc(sizeof(subAreaNode));
             node->addr = p->addr +size;
             node->size = p->size -size;
             node->state = Free;
             node->taskId = -1;
              //修改分區鏈節點指針
             node->pre = p;
             node->nxt = p->nxt;
             if(p->nxt != NULL) {
                p->nxt->pre  =node;
             }
             p->nxt = node;
              //分配空閑區間
             p->size = size;
             p->state = Busy;
             p->taskId = taskId;
          }
          printf("內存分配成功！n");
          return 1;
       }
       p =p->nxt;
   }
   printf("找不到合適的內存分區，分配失敗...n");
    return0;
}// 最佳適應算法int bestFit(int taskId, int size)
{
   subAreaNode *tar = NULL;
    inttarSize = SIZE + 1;
   subAreaNode *p = subHead.nxt;
    while(p!= NULL)
   {
       // 尋找最佳空閑區間
       if(p->state ==Free && p->size>= size &&p->size < tarSize) {
          tar = p;
          tarSize = p->size;
       }
       p =p->nxt;
   }
    if(tar!= NULL) {
       // 找到要分配的空閑分區
       if(tar->size -size <= MINSIZE) {
              //整塊分配
             tar->state = Busy;
             tar->taskId = taskId;
          } else {
              //分配大小為size的區間
             subAreaNode *node = (subAreaNode*)malloc(sizeof(subAreaNode));
             node->addr = tar->addr +size;
             node->size = tar->size -size;
             node->state = Free;
             node->taskId = -1;
              //修改分區鏈節點指針
             node->pre = tar;
             node->nxt = tar->nxt;
             if(tar->nxt != NULL) {
                tar->nxt->pre  =node;
             }
             tar->nxt = node;
              //分配空閑區間
             tar->size = size;
             tar->state = Busy;
             tar->taskId = taskId;
          }
          printf("內存分配成功！n");
          return 1;
    } else{
       // 找不到合適的空閑分區
      printf("找不到合適的內存分區，分配失敗...n");
       return 0;
   }
}// 回收內存int freeSubArea(int taskId)
{
    intflag = 0;
   subAreaNode *p = subHead.nxt, *pp;
    while(p!= NULL)
   {
       if(p->state ==Busy && p->taskId ==taskId) {
          flag = 1;
          if((p->pre !=&subHead &&p->pre->state ==Free) 
             && (p->nxt != NULL&&p->nxt->state == Free)) {
              //情況1：合并上下兩個分區
              //先合并上區間
              pp =p;
              p =p->pre;
             p->size += pp->size;
             p->nxt = pp->nxt;
             pp->nxt->pre = p;
             free(pp);
              //后合并下區間
              pp =p->nxt;
             p->size += pp->size;
             p->nxt = pp->nxt;
             if(pp->nxt != NULL) {
                pp->nxt->pre = p;
             }
             free(pp);
          } else if((p->pre ==&subHead ||p->pre->state == Busy)
             && (p->nxt != NULL&&p->nxt->state == Free)) {
              //情況2：只合并下面的分區
              pp =p->nxt;
             p->size += pp->size;
             p->state = Free;
             p->taskId = -1;
             p->nxt = pp->nxt;
             if(pp->nxt != NULL) {
                pp->nxt->pre = p;
             }
             free(pp);
          } else if((p->pre !=&subHead &&p->pre->state == Free)
             && (p->nxt == NULL|| p->nxt->state == Busy)){
              //情況3：只合并上面的分區
              pp =p;
              p =p->pre;
             p->size += pp->size;
             p->nxt = pp->nxt;
             if(pp->nxt != NULL) {
                pp->nxt->pre = p;
             }
             free(pp);
          } else {
              //情況4：上下分區均不用合并
             p->state = Free;
             p->taskId = -1;
          }
       }
       p =p->nxt;
   }
    if(flag== 1) {
       // 回收成功
      printf("內存分區回收成功...n");
       return 1;
    } else{
       // 找不到目標作業，回收失敗
      printf("找不到目標作業，內存分區回收失敗...n");
       return 0;
   }
}// 顯示空閑分區鏈情況void showSubArea()
{
   printf("*********************************************n");
   printf("**        當前的內存分配情況如下：      **n");
   printf("*********************************************n");
   printf("** 起始地址 | 空間大小 | 工作狀態 | 作業號 **n");
   subAreaNode *p = subHead.nxt;
    while(p!= NULL)
   {
      printf("**-----------------------------------------**n");
       printf("**");
      printf("%d  k |", p->addr);
      printf("%d  k |", p->size);
       printf("  %s   |", p->state == Free ? "Free": "Busy");
       if(p->taskId> 0) {
          printf("%d  ", p->taskId);
       } else {
          printf("       ");
       }
      printf("**n"); 
       p =p->nxt;
   }
   printf("*********************************************n");
}

int main()
{
    intoption, ope, taskId, size;
    //初始化空閑分區鏈
   intSubArea();
    //選擇分配算法
   while(1)
   {
      printf("請選擇要模擬的分配算法：
          0 表示首次適應算法，1 表示最佳適應算法n");
       scanf("%d",&option);
       if(option == 0) {
          printf("你選擇了首次適應算法，下面進行算法的模擬n");
          break;
       } else if(option == 1){
          printf("你選擇了最佳適應算法，下面進行算法的模擬n");
          break;
       } else {
          printf("錯誤：請輸入 0/1nn");
       }
   }    //模擬動態分區分配算法
   while(1)
   {
       printf("n");
      printf("*********************************************n");
       printf("** 1: 分配內存    2:回收內存    0: 退出 **n");
      printf("*********************************************n");
       scanf("%d",&ope);
       if(ope == 0)break;
       if(ope == 1) {
          // 模擬分配內存
          printf("請輸入作業號： ");
          scanf("%d", &taskId);
          printf("請輸入需要分配的內存大小(KB)： ");
          scanf("%d", &size);
          if(size <= 0) {
             printf("錯誤：分配內存大小必須為正值n");
             continue;
          }
          // 調用分配算法
          if(option == 0) {
             firstFit(taskId, size);
          } else {
             bestFit(taskId, size);
          }
          // 顯示空閑分區鏈情況
          showSubArea();
       } else if(ope == 2){
          // 模擬回收內存
          printf("請輸入要回收的作業號： ");
          scanf("%d", &taskId);
          freeSubArea(taskId);
          // 顯示空閑分區鏈情況
          showSubArea();
       } else {
          printf("錯誤：請輸入 0/1/2n");
       }
   }
   printf("分配算法模擬結束n");
    return0;
}

上述就是小編為大家分享的如何進行windows操作系統動態分區分配方式原理詳解與代碼測試了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。