操作系统作业02

最新推荐文章于 2024-10-10 09:38:20 发布
最新推荐文章于 2024-10-10 09:38:20 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： 操作系统作业 文章标签： 链表 c语言 操作系统作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Seth_2015/article/details/61614469
版权

操作系统作业02

题目

请编写一个程序，模拟若干进程调度执行的情况。假设进程的状态分为执行和就绪两种。每个进程以其PCB为代表即可，无需创建真正的进程。

以链表的方式组织PCB，分为三个队列： freeQueue：一个空白PCB队列 readyQueue：一个就绪队列
runningQueue：一个执行队列

程序开始运行时，用户输入进程数量n，以及每个进程需要运行的时间t0/t1/…/tn。程序从空白PCB队列中取出PCB创建进程，插入readyQueue。

进程的调度采用随机的方式，即从就绪队列中随机选择一个进程投入运行（就是将该PCB中的状态变量赋值为“运行”）。相应的修改其所在队列，并且原来处于运行态的进程需要转变为“就绪”态，插入readyQueue。

假设时间片是2，进程每次调度运行后，其还需运行的时间应该减少2，直至为0，即表示该进程执行完毕。需要回收PCB到freeQueue。

每次发生调度的时候，需要打印信息示例： Sched: P0(Running -> Ready), P3(Ready -> Running)
Running: P3 Ready: P1->P2->P0
上述信息表示调度时P0处于运行态，选择P3运行，P0进程的PCB进入就绪队列，并且在队尾。就绪队列是按照队列节点次序输出进程名称。
示例片段代码：

#define free 0
#define ready 1
#define running 2
#define ts 2 /* time slice */ struct PCB {
int pid; /* 进程ID */
int pstate; /* 进程状态 */
char pname; / 映象名称 */
int ptime; /* 剩余运行时间 */
struct PCB pnext; / 下一个PCB */ }

代码实现

#include<stdio.h>
#include<malloc.h>
#include <string.h>
#include<stdlib.h>
#include<time.h>

#define free 0
#define ready 1
#define running 2
#define ts 2 /* time slice */
struct PCB {
    int pid;    /* 进程ID  */
    int pstate;  /* 进程状态 */
    char pname[20]; /* 映象名称 */
    int ptime;   /* 剩余运行时间 */
    struct PCB *pnext;  /* 下一个PCB */
};
/*产生随机数并用于随机调度*/
int PCBchange(int isEmpty[],int run,int PCB_num){
    int lrun = rand()%PCB_num;

    while(run==lrun || isEmpty[lrun]<0){                //获取随机调度目标id，并防止重复

        lrun = rand()%PCB_num;
    }
    return lrun;
}


/*在就绪队列查找调度目标并完成切换*/
struct PCB * findAndSwitch(int Id,struct PCB * tp,struct PCB * sp){
    struct PCB * getP;
    struct PCB * temp;
    getP = tp;    //寻找调度进程的位置
    while(getP->pnext!=NULL&&getP->pnext->pid != Id){
        getP = getP->pnext;
    }
    /*就绪队列以及运行队列的进程切换*/
        temp = getP->pnext;
    if(temp->pnext!=NULL){
        getP->pnext = temp->pnext;  //readyQueue链表操作
    }else{
        getP->pnext = NULL;
    }

    getP = sp->pnext;

    sp->pnext = temp; //连接到running链表中
    temp->pnext = NULL;         //清零后续位

    return getP;
}

/*输出readyQueue*/
void outputReady(struct PCB* tp){
    struct PCB* getP;

    printf("Ready:");
    if(tp->pnext!= NULL){
        getP = tp->pnext;
        printf("%s",getP->pname);   //输出首个元素
        getP = getP->pnext;
        while(getP!=NULL){          //循环输出后续元素
            printf("->%s",getP->pname);
            getP = getP->pnext;
        }
        printf("\n");
    }else
        printf("NULL\n");
}



int main()
{

    struct PCB * freeQueue = (struct PCB*)malloc(sizeof(struct PCB));
    struct PCB * readyQueue = (struct PCB*)malloc(sizeof(struct PCB));
    struct PCB * runningQueue = (struct PCB*)malloc(sizeof(struct PCB));
    struct PCB * temp;                     //辅助操作指针
    struct PCB * getP;                      //同上
    int PCB_num;                        //储存进程数量
    char str[10];                       //初始化各进程name
    int isEmpty[50]={0};                //记录各进程是否执行完毕的数组
    int i=0;                            //辅助参数
    int run=-1;                         //储存随机调度目标id
    int counter = 0;                    //记录已运行完毕进程的数量
    int isComplete=1;                   //主循环是否继续的标志位

    srand((unsigned) time(NULL));   //产生种子用于随机调度

    /*初始化POB*/
    runningQueue->pnext = NULL;
    printf("请输入进程数量：");
    scanf("%d",&PCB_num);
    printf("请依次输入每个进程运行耗时：");
    getP = freeQueue;
    for(i;i<PCB_num;i ){
        temp = (struct PCB*)malloc(sizeof(struct PCB));     //请求动态储存空间
        temp->pid = i;                              //记录id
        temp->pstate = 0;                           //初始化状态
        sprintf(str, "%d" , i);                     //name操作
        memset(temp->pname, 0, 20);                 //初始化字符串
        temp->pname[0] = 'P';
        strcat(temp->pname, str);
        scanf("%d",&(temp->ptime));                 //输入进程运行所需时间
        temp->pnext = NULL;                         //初始化pnext指针
        getP->pnext = temp;                         //链表连接
        getP = getP->pnext;
        isEmpty[i] = i;                             //初始化记录数组
    }

    /*转换到就绪队列*/
    readyQueue->pnext = freeQueue->pnext;       //进入就绪队列
    freeQueue->pnext = NULL;

    /*运行并随机调度*/
    while(isComplete){
        run = PCBchange(isEmpty, run, PCB_num);       //获取随机值

        if(runningQueue->pnext==NULL){
            /*首次运行*/
            getP = findAndSwitch(run,readyQueue,runningQueue);     //定位目标进程并完成切换

            /*输出*/
            printf("Sched:%s(Ready->Running)\n",runningQueue->pnext->pname);
            printf("Running:%s\n",runningQueue->pnext->pname);
            outputReady(readyQueue);
        }
        /*判断调度是否是自己*/
//        else if(run==runningQueue->pnext->pid){
//            printf("Sched:%s(Running->Runing)\n",runningQueue->pnext->pname);
//            printf("Running:%s\n",runningQueue->pnext->pname);
//            outputReady(readyQueue);
//        }
        /*后续运行*/
        else{
            getP = findAndSwitch(run, readyQueue, runningQueue);  //定位目标进程并完成切换

            temp = readyQueue;              //连接到readyQueue链表尾部
            while(temp->pnext!=NULL)
                temp = temp->pnext;
            temp->pnext = getP;             //将进入就绪队列的进程放在队尾

            /*输出*/
            printf("Sche:%s(Running->Ready),%s(ready->Running)\n",
                   getP->pname,runningQueue->pnext->pname);
            printf("Running:%s\n", runningQueue->pnext->pname);
            outputReady(readyQueue);
            }

        runningQueue->pnext->ptime -= 2;        //进程时间-2

        /*将就绪队列中运行完毕的进程转到空队列*/
        for(i=0;i<PCB_num; i){
            if(isEmpty[i] == -1)
            {
                isEmpty[i] = -2;
                temp = readyQueue;
                while(temp->pnext->pid != i)
                    temp = temp->pnext;
                if(temp->pnext!=NULL){
                    getP = temp->pnext;
                    temp->pnext = getP->pnext;
                }else{
                    getP = temp->pnext;
                    temp->pnext = NULL;
                }

                    getP->pnext = freeQueue->pnext; //free链表连接
                    freeQueue ->pnext = getP;
                printf("Sche:%s(Ready->free)\n",getP->pname);
                counter ;                      //已完成进程数量加一
            }
        }
        if(runningQueue->pnext->ptime<=0){      //判断运行进程是否运行完毕
            isEmpty[run] = -1;
        }
        if(counter == PCB_num-1){               //判断所有进程是否运行完毕
            printf("Sche:%s(Ready->free)\n",runningQueue->pnext->pname);
            isComplete = 0;
        }

    }
    return 0;

}

运行结果

输入4个进程的实际运行结果
这里写图片描述

小结

本次作业，发现了很多不足，比如在链表操作时经常遇到空指针问题，代表自己的指针操作还是不甚熟料，同时，犯了上手就写代码的错误，导致后期很多链表操作的代码重复，以至于后期不易调试导致我几乎重写把链表全都封到函数中，不过就算现在的代码逻辑也不是很清晰，下次一定要先构思再下手

Seth_2015
关注
专栏目录
C语言实现模拟进程调度
rq8866的博客
10-19 1926
请编写一个程序，模拟若干进程调度执行的情况。假设进程的状态分为执行和就绪两种。每个进程以其PCB为代表即可，无需创建真正的进程。 ```c #include <stdio.h> #include <stdlib.h> #include <time.h> #include <windows.h> #define free 0 #define read...
【操作系统实验6】CPU调度程序模拟实现
qq_44394952的博客
01-04 1873
加深对操作系统CPU调度以及调度算法的理解。
操作系统c语言模拟进程调度实验
11-12
C语言，运行成功，比较基础，c语言模拟设计一个有N个进程运行的进程调度程序，用最高优先数优先法：在创建进程时，给定一个进程优先数，并按一定规则减少优先数，直至所有进程运行完成（例如进程每获得一次cpu进程数减1）
进程的三种状态及转换
uyehniy的专栏
04-15 1751
1.进程的三种基本状态     进程在运行中不断地改变其运行状态。通常，一个运行进程必须具有以下三种基本状态。  就绪(Ready)状态     当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。  执行（Running）状态 当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。  阻塞(Bloc
操作系统作业答案
07-01
天津大学的计算机作业围绕操作系统的重要概念展开，涉及进程管理、内存管理、磁盘调度和多选择题等多个方面。下面我们将详细探讨这些知识点。 1. **进程管理**： - **进程定义**：进程是程序在执行过程中的一个...
操作系统课件：02第二章 进程线程与作业.ppt
06-26
操作系统课件：02第二章 进程线程与作业 本章节主要讲述了操作系统中进程、线程和作业的概念和相关知识点。下面是从给定的文件中生成的相关知识点： 多道程序设计 多道程序设计是操作系统中的一种设计思想，旨在...
操作系统原理作业-支持多进程并发的操作系统源码+项目说明.zip
12-20
操作系统原理作业-支持多进程并发的操作系统源码+项目说明.zip 文件结构： src文件夹中包含4个文件夹、1个.asm文件。 1. img文件夹中包含了本次实验的1个映像文件XOS5.0，XOS5.0是本次实验的最终完成品。 2. ...
南京信息工程大学专业课操作系统大作业内含源码和报告.zip
04-21
2. **02 操作系统B卷.doc**：这可能是一个额外的考试卷或者练习题，可能包含与操作系统相关的不同问题，如系统调用、操作系统的结构、进程调度算法、虚拟存储器的工作原理等。这样的练习有助于加深对操作系统的理解...
操作系统：02第二章 进程线程与作业.ppt
06-17
"操作系统：02第二章 进程线程与作业" 操作系统是计算机科学中最基本的一门学科，它研究计算机硬件和软件的交互关系，学习操作系统可以帮助我们更好地理解计算机的工作原理和运行机制。本章主要讲述了进程、线程和...
操作系统 先来先服务调度算法c语言（文档+源代码+演示结果）
11-20
操作系统 先来先服务调度算法c语言（文档+源代码+演示结果）
操作系统进程调度先到先服务&&短作业优先算法 c语言实现
05-05
用C语言编程实现先来先服务和最短作业优先调度算法(设计型实验)
模拟状态1
chenbingchenbing的专栏
03-14 244
<br />(defun  test ()<br />(lambda (x)<br />     (lambda (y)<br />       (if  (eq  y  'count)  <br />                x<br />            (print  y)<br />       )<br />      )<br />   )<br />)<br /><br />(setq  chenbing  (test) )<br />(setq  a   (funcall  ch
操作系统用C语言编写程序，模拟实现创建新的进程：查看运行进程；换出某个进程：杀死运行进程等功能。
热门推荐
Sum
06-03 1万+
进程管理实验目的实验内容实验步骤实验代码 实验目的 1．理解进程的概念，明确进程和程序的区别 2．理解并发执行的实质。 3．掌握进程的创建、睡民、撤销等进程控制方法。 实验内容 用C语言编写程序，模拟实现创建新的进程：查看运行进程；换出某个进程：杀死运行进程等功能。 实验步骤 进程 1．进程的含义 进程是程序在一个数据集合上的运行过程，是系统资源分配和调度的一个独立单位。一个程序在不同数据集合上运行，乃至一个程序在同样数据集合上的多次运行都是不同的进程。 2．进程的状态 通常，一个进程必须具有就绪、执行和阻
多级队列反馈调度算法
shakingWaves的专栏
11-13 2535
#include #include #include typedef struct processNode    /*进程节点信息*/{ char name[20];      /*进程的名字*/ int prio;       /*进程的优先级*/ int round;       /*分配CPU的时间片*/ int cputime;      /*CPU执行时间*/ int needtime;      /*进程执行所需要的时间*/ char state;       /*进程的状态，W——就绪态，R—
C++结构体里面string类型赋值问题
weixin_34392906的博客
07-09 2298
234567891011121314#include<string>usingnamespacestd;structtemp{strings;};intmain(){conststringp="aaa";temp*q;q=(structtemp*)malloc(sizeof(structtemp));q-...
时间片轮算法c
qq_50509331的博客
11-29 392
#include<stdio.h> #include<stdlib.h> #define NUM 10 typedef struct PCB { int name;//进程id int runtime;//剩余需要执行的时间，可随机分配 int runedtime;//已经执行的时间 int state;//执行状态,0表示没完成，1表示完成 struct PCB *next; }PCB; int main() { ...
【最新华为OD机试E卷-支持在线评测】补种未成活胡杨(100分)多语言题解-(Python/C/JavaScript/Java/Cpp)
最新发布
春秋招笔试突围
10-10 167
🍭 大家好这里是，一枚热爱算法的程序员💻 ACM金牌🏅️团队 ｜ 大厂实习经历 ｜ 多年算法竞赛经历✨ 本系列打算持续跟新的多语言AC题解🧩 大部分包含PythonCJavascriptJavaCpp多语言代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值