操作系统课程实验代码汇总

最新推荐文章于 2022-11-17 21:27:37 发布

VIP文章思维矩阵K

最新推荐文章于 2022-11-17 21:27:37 发布

阅读量1.2k

点赞数 3

分类专栏：分享文章标签：操作系统算法程序人生经验分享

本文链接：https://blog.csdn.net/ZhaoProgrammer/article/details/111538054

版权

操作系统课程实验代码汇总

本次内容供需要有相关实验需要的提供参考，代码下载方式在文末

前言

本次更新的是操作系统课程实验的代码和实验内容

提示：以下是本篇文章正文内容，下面案例可供参考：主要涉及的实验有：1.进程管理、2.进程调度、3.银行家算法、4.虚拟存储器管理、5.设备管理、6、spooling技术

一、进程管理

实验目的

理解进程概念，明确进程和程序的区别。
理解并发执行的实质。
掌握进程的创建和撤销等进程控制方法。

代码

主函数

#include "ProcessControl.h"

void showLine(){
   
    printf("**************************\n");
}

int main(int argc, const char * argv[]) {
   
    
    //运行(就绪)队列(头结点不储存信息)
    PCB *running_list = (PCB *)malloc(sizeof(PCB));
    running_list->next = NULL;
    
    //阻塞队列(头结点不储存信息)
    PCB *block_list = (PCB *)malloc(sizeof(PCB));
    block_list->next = NULL;
    
    //当前运行的进程数量
    int storage_number = 0;
    
    int choose = 1;
    while (choose) {
   
        //展示菜单
        showLine();
        printf("*     进程演示系统      *\n");
        showLine();
        printf("1.创建新的进程  2.查看运行进程\n");
        printf("3.换出某个进程  4.杀死运行进程\n");
        printf("5.唤醒某个进程  6.退出程序   \n");
        showLine();
             
        printf("请选择(1~6):\n");
        scanf("%d",&choose);
             
        switch (choose) {
   
            case 1:
                //创建新的进程
                create(running_list, block_list, &storage_number);
                break;
            case 2:
                //查看运行进程
                show_running(running_list);
                break;
            case 3:
                //换出某个进程
                change(running_list, block_list, &storage_number);
                break;
            case 4:
                //杀死运行进程
                killed(running_list, &storage_number);
                break;
            case 5:
                //唤醒某个进程
                wake_up(running_list, block_list, &storage_number);
                break;
            case 6:
                return 0;
            default:
                printf("没有这个选项!\n");
                break;
        }
             
    }
      
    return 0;
}

另外还有两个文件就不展示出来，代码资源会上传供下载使用

说明

打开程序后，进入界面可以看到6各功能模块，可根据操作系统知识来完成相应操作
用C语言编写程序，模拟实现创建新的进程；查看运行进程；换出某个进程；杀死运行进程等功能。
程序运行后出现界面，提供“创建新的进程”、“查看运行进程”等6项功能供用户选择，用户通过在界面输入各个功能所对应的标号选择执行不同的功能。

二、进程调度

实验目的

理解有关进程控制块，进程队列的概念。
掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。
代码如下：

#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
// using namespace std;
 #define JOBSUM    9    //进程/作业总数
#define JOBNUM    5    //允许的作业道数
#define PRITOP    3    //最高优先级级数
 #define TIMELIMIT 10    //时间限制
 
struct Job{
       //作业
char jname[40];    //作业名
int start;    //到达时间
int worktime;    //工作时间
Job *next; //链接指针
int   pri; 
 };

 struct PCB{
   
 PCB* next;
 char pname[40];    //进程名
int time;    //进程运行时间 
 char status;    //运行状态
};

bool CreateJob(Job* jobtable,char name[])    //创建作业，将作业放入作业调度表
{
   
    //随机生成一个作业
     Job *p = new Job;
    strcpy(p->jname,name);
     p->start = rand()%(TIMELIMIT-1)+1;
p->worktime = rand()%(TIMELIMIT-p->start)+1;
p->pri = rand()%PRITOP;
p->next = NULL;

  //将作业放入作业调度表
   Job* now = jobtable;
 
 //将作业放入作业调度表，按到达时间排序
      if(now->next==NULL){
       //后备队列还是空的时候
          now->next = p;}
      else{
   
          if(p->start <= now->next->start){
       //当新生成的作业工作时间比后备队列第一个作业工作时间就小
             p->next = now->next;
             now->next = p;
          }
         else{
   
             Job *q = now->next;
            while( (p->start > q->start) && (q->next!=NULL) ){
       //找到插入的位置
                 q = q->next;
              }
            if( (p->start > q->start) && q->next==NULL){
       //新生成的作业的start比后备队列中所有作业的start都大，则排在最后
                q->next = p;
              }
             else if(p->start <= q->start){
       //找到插入的位置，这个位置的start小于或者等于下一个节点的start
                 Job *t = now->next;
                  while(t->next!=q){
   
                     t = t->next;
                 }
                  t->next = p;
                  p->next = q;
              }
          }
     }
 
     return true;
 }
 
 bool AddHoubei(Job *jobtable,Job *p,Job *&jhead)    //将作业p放入后备队列jhead，按短作业优先放置
  {
   
      //将作业p从作业调度表jobtable中去除
     Job* q = jobtable;
      while(q->next!=p && q->next!=NULL){
   
          q = q->next;
      }
      if(q->next==p){
   
          q->next = p->next;
          p->next = NULL;
      }
  
      //将作业p放入后备队列jhead，按短作业优先放置
     if(jhead==NULL){
       //后备队列还是空的时候
          jhead = p;
      }
    else{
   
         if(p->worktime <= jhead->worktime){
       //当新生成的作业工作时间比后备队列第一个作业工作时间就小
              p->next = jhead;
              jhead = p;
          }
          else{
   
             Job *q = jhead;
             while( (p->worktime > q->worktime) && (q->next!=NULL) ){
       //找到插入的位置
                  q = q->next;
              }
              if( (p->worktime > q->worktime) && q->next==NULL){
       //新生成的作业的worktime比后备队列中所有作业的worktime都大，则排在最后
                 q->next = p;
             }
             else if(p->worktime <= q->worktime){
       //找到插入的位置，这个位置的worktime小于或者等于下一个节点的worktime
                 Job *t = jhead;
                 while(t->next!=q){
   
                    t = t->next;
                 }
                 t->next = p;
                 p->next = q;
             }
         }
     }
     return true;
 
 }
 
 bool CreateProcess(PCB* &head,PCB* &tail,Job* &jhead)    //创建新进程
 {
   
     PCB* p = new PCB;
     char JobID = jhead->jname[3];
     strcpy(p->pname,"Process");    //进程名 
     p->pname[7] = JobID;
     p->pname[8] = '\0';
     p->status = 'R';    //就绪状态
     p->time = jhead->worktime;        //进程工作时间
 
     if(tail==NULL){
   
         //就绪队列还是空的，则第一次赋值
         head = p;
         tail = head;
         tail->next = head;
     }
     else{
   
         //就绪队列不为空
         tail->next = p;
         tail = p;
         p->next = head;
     }
 
     return true;
}
 
 bool Work(PCB* now)    //当前进程执行
 {
   
    now->time--;
 
     return true;
 }
 
 bool DropPro(PCB* &head,PCB* &tail,PCB* &chead,PCB* &ctail)    //将队首进程，推出循环就绪队列
 {
   
     PCB* p = head;        //保存头节点
     head = head->next;    //头结点指向他的下一个节点
     tail->next = head;    //将就绪队列尾节点直接指向新的头节点
     p->next = NULL;        //将分离出来的原来的头节点的next设为空NULL
 
     if(ctail==NULL){
   
         //已完成进程队列还是空的，则第一次赋值
         chead = p;
         ctail = chead;
     }
     else{
   
         //已完成进程队列不为空，则将当前已完成进程放到队列尾部
         ctail->next = p;
         ctail = ctail->next;
     }
 
    return true;
 }
 
 bool NextPro(PCB* &head,PCB* &tail)    //当前进程已执行了一个时间片，将其置于循环队列尾端。即将head和tail向前推进一次
 {
   
     head = head->next;
     tail = tail->next;
 
     return true;
 }
 

 void printRQ(PCB* head,int readynum)    //打印当前就绪队列
 {
   
     PCB* p = head;
     printf("=> ");
     if(readynum==0){
   
         //就绪队列已空
        printf("空\n");
         return ;
     }
     while(p->next!=head){
   
         printf("%s->",p->pname);
         p = p->next;
     }
     printf("%s\n",p->pname);
 }

void printCQ(PCB* chead,PCB* ctail)    //打印当前已完成进程队列
 {
   
     PCB* p = chead;
     printf("=> ");
     if(chead==NULL){
   
         //已完成进程队列队列已空
         printf("空\n");
         return ;
     }
     while(p!=ctail){
   
         printf("%s->",p->pname);
         p = p->next;
     }
     printf("%s\n",p->pname);
 }
 
 void printJQ(Job* jhead)    //打印当前后备队列
 {
   
     Job* p = jhead;
     printf("=> ");
    if(jhead==NULL){
   
        printf("空\n");
         return ;
    }
     while(p->next!=NULL){
   
         printf("%s->",p->jname);
        p = p->next;
     }
     printf("%s\n",p->jname);
 }
 
 void getJobName(int i,char name[])    //获得当前进程名 
 {
   
     //进程名
     strcpy(name,"Job");
     int len = strlen(name);
     name[len] = '0'+i;
     name[len+1] = '\0';
 }
 

 void printProInfo(PCB* now)    //打印当前进程信息
 {
   
     if(now==NULL){
   
         printf("当前没有进程\n");
        return ;
    }
     printf("# 当前进程为\n");
     printf("进程名:%s\n",now->pname);
     printf("运行时间:%d\n",now->time);
     printf("进程状态:%c\n",now->status);
 }
 
 void printAllJobInfo(Job* jhead)    //输出所有作业信息
 {
   
     Job* p = jhead->next;
     printf("\t--- 作业调度表 ---\n");
     printf("作业名\t");
     printf("到达时间\t");
     printf("工作时间\n");
     while(p!=NULL){
   
         printf("%s\t",p->jname);
         printf("%d\t\t",p->start);
         printf("%d\n",p->worktime);
         p = p->next;
     }
 }

 
 void printQueueInfo(Job *jobtable,Job *jhead,PCB *head,PCB *rhead,PCB *chead,int tablenum,int houbeinum,int readynum)    //打印所有队列信息
 {
   
     printf("\n");
     printf("--- 运行队列 & 就绪队列 & 已完成队列 ---\n");
     printf("进程名\t\t");
     printf("运行时间\t");
    printf("进程状态\t");
     printf("\n");
 
     PCB *p = NULL;
     //输出运行队列信息
     if(readynum!=0){
   
         p = rhead;
         printf("%s\t",p->pname);
         printf("%d\t\t",p->time);
         printf("%c\t",'W');
         printf("\n");
     }
 
     //输出就绪队列信息
     if(readynum!=0){
   
        p = head->next;
         while(p!=head){
   
             printf("%s\t",p->pname);
             printf("%d\t\t",p->time);
             printf("%c\t",p->status);
            printf("\n");
            p = p->next;
         }
     }
 
    //输出完成队列
     if(chead!=NULL){
       //完成队列不为空
         p = chead;
         while(p!=chead){
   
             printf("%s\t",p->pname);
            printf("%d\t\t",p->time);
            printf("%c\t",p->status);
             printf("\n");
             p = p->next;
         }
     }

 
     printf("\n");
     printf("\t--- 后备队列 ---\n");
     printf("作业名\t");
     printf("到达时间\t");
     printf("工作时间\t");
     printf("\n");
 
     Job *q;
     //输出后备队列
     if(houbeinum!=0){
   
         q = jhead;
         while(q!=NULL){
   
             printf("%s\t",q->jname);
            printf("%d\t\t",q->start);
             printf("%d\t",q->worktime);
             printf("\n"<

最低0.47元/天解锁文章

思维矩阵K

关注

3
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
0
评论
操作系统课程实验代码汇总

操作系统课程实验代码汇总本次内容供需要有相关实验需要的提供参考文章目录操作系统课程实验代码汇总前言一、进程管理实验目的：代码使用方法二、使用步骤1.引入库2.读入数据总结前言本次更新的是操作系统课程实验的代码和实验内容提示：以下是本篇文章正文内容，下面案例可供参考：主要涉及的实验有：1.进程管理、2.进程调度、3.银行家算法、4.虚拟存储器管理、5.设备管理、6、spooling技术、7.文件系统、8、操作系统接口一、进程管理实验目的：理解进程概念，明确进程和程序的区别。理解并发执
复制链接

扫一扫