c语言进程管理,OS进程管理模拟（C语言实现）

最新推荐文章于 2022-03-30 16:28:41 发布
最新推荐文章于 2022-03-30 16:28:41 发布
阅读量1.3k 收藏 3
点赞数 1
文章标签： c语言进程管理

实验原理和方法

1.

进程(Process)是计算机中的程序关于其数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

1)动态性、并发性、独立性、异步性。

2)程序是静态的概念，进程是程序在处理机上的一次执行过程，它是一个动态的概念。

3)进程由程序、数据和进程控制块PCB三部分组成。

4)运行中的进程可能具有以下三种基本状态：就绪、运行、等待。

2. 进程控制是进程管理中最基本的功能。它用于创建一个进程，终止或撤销一个进程，还负责进程运行过程中的状态转换。

3.

实验是模拟性质的实验，即不以真实的操作系统的系统调用及其各种数据结构进行操作。在程序中创建一个记录数组以作为进程的PCB结构来进行有关的操作。通过模拟进程的创建、初始化、修改进程控制块的状态标志，实现对进程管理的简单模拟。

4. 实验采用的进程调度策略：简单的时间片轮转算法RR。

1)时间片轮转算法RR：每个进程被分配一个时间段，又称为时间片，也就是该进程允许运行的时间。如果在时间片结束时，进程还没运行完，则CPU被分派给另一个就绪的进程。如果运行中的进程在时间片结束前被等待或运行结束，则CPU进行切换。

主要数据结构的定义和描述

//计时器

typedef struct _time {

int seconds; //秒

int minutes; //分

int hours; //时

}TIME,*LPTime;

//进程控制块

typedef struct Node{

int pid;

int time_need;

int time_used;

char status;

struct Node *pNext;

}Node,*PCB;

程序模块构成

1)时间控制模块。

2)进程变迁模块。

3)输出模块。

主要算法的模型或描述

运用一个计时器(秒表)来记录时间，每三秒生成若干进程(可以不生成)。

程序主体：

for(;;) {//死循环来记录时间

special = random(5);//特殊事件

wakeup = random(5);//唤醒事件

UpdateTime(systemtime);//不断更新时间

if(pReady->pNext == NULL && pRun->pNext == NULL

&& pBlock->pNext == NULL){//就绪、运行、阻塞队列全空，退出程序

exit(1);

}

//每三秒创建若干进程

if(miao % 30 == 0){

update_ready(pReady);

}

//运行队列空，就绪队列进程被调度

if(pRun->pNext == NULL && pReady->pNext != NULL

){

ready_run(pReady,pRun);

run(pRun);

}

//时间片消耗

if(pRun->pNext != NULL){

pRun->pNext->time_used ;

//时间片耗完

if(pRun->pNext->time_used % 60 == 0){

timeout(pReady,pRun);

ready(pReady);

}

//进程完成

if( pRun->pNext->time_used >=

pRun->pNext->time_need){

run_finish(pRun,pFinish);

finish(pFinish);

}

}

//特殊事件发生，进程等待事件

if(special == 0 && pRun->pNext != NULL ){

run_block(pRun,pBlock);

block(pBlock);

}

//唤醒事件发生，阻塞进程被唤醒

if(wakeup == 1 && pBlock->pNext != NULL){

Block_ready(pBlock,pReady);

ready(pReady);

}

//每1/10s执行依次循环

Sleep(100);

}

程序运行的主要画面截图及其说明

初始状态：5个就绪进程(图1)。

a4c26d1e5885305701be709a3d33442f.png

图 1

当运行队列为空时，发生调度。就绪队列对头自动进入运行队列，随之发生状态改变(r->e)图2)。

a4c26d1e5885305701be709a3d33442f.png

图 2

时间片消耗完，运行进程进入就绪队列，随之状态改变(e->f)(图3)

a4c26d1e5885305701be709a3d33442f.png

图 3

当发生特殊事件时(如请求I/O)，运行进程进入阻塞队列，随之发生状态改变(e->b)

(图4，图 5)。.

a4c26d1e5885305701be709a3d33442f.png

图4

a4c26d1e5885305701be709a3d33442f.png

图 5

每三秒生成若干进程(生成了1个进程)(图6)

a4c26d1e5885305701be709a3d33442f.png

图 6

当发生唤醒事件时，阻塞进程进入就绪队列，随之发生状态改变(b->r)

a4c26d1e5885305701be709a3d33442f.png

图 7

程序执行完成(图8)。

a4c26d1e5885305701be709a3d33442f.png

图 8

源程序代码

#include

#include

#include

#include

#include

#include

#include

int id = 1;

int miao = 0; //该时间用来记录每3S生成若干进程

int timeSlice = 0; //该时间 用来记录时间片

int special = 0; //特殊事件(请求I/O等)

int wakeup = 0; //唤醒事件

//时间

typedef struct _time {

int seconds;

int minutes;

int hours;

}TIME,*LPTime;

//进程

typedef struct Node{

int pid;

int time_need;

int time_used;

char status;

struct Node *pNext;

}Node,*PCB;

//初始化时间表

LPTime InitTime(LPTime time)

{

time=(LPTime)malloc(sizeof(TIME));

if (!time)

{

printf("Error!!!\n");

exit(0);

}

time->hours =0;

time->minutes =0;

time->seconds =0;

return time;

}

//更新时间

void UpdateTime(LPTime time)

{

time->seconds ;

timeSlice ;

miao ;

timeSlice ;

if(time->seconds==10)

{

time->seconds=0;

time->minutes ;

}

if(time->minutes==60)

{

time->minutes=0;

time->hours ;

}

}

//显示时间

void ShowTime(LPTime time)

{

printf("d:",time->hours);

printf("d:",time->minutes);

printf("d\r",time->seconds);

}

//产生随机数

int random(int a){

int i;

srand((int)time(0));

return

rand() % a;

}

//创建进程

PCB fork(int n)

{

int

i, len, val;

PCB

pHead = (PCB)malloc(sizeof(Node));

len

= n;

PCB

pTail = pHead;

pTail->pNext

= NULL;

for(i=0;

i

{

PCB

pNew = (PCB)malloc(sizeof(Node));

pNew->pid

= id ;

pNew->status

= 'r';

pNew->time_need

= random(20);

pNew->time_used

= 0;

pTail->pNext

= pNew;

pNew->pNext

= NULL;

pTail

= pNew;

}

return

pHead;

}

//显示进程队列

void view(PCB pHead)

{

PCB

p = pHead->pNext;

while(p

!= NULL) {

printf("

%d %d %d %c\n",

p->pid,p->time_need,p->time_used,p->status);

p

= p->pNext;

}

printf("\n");

return;

}

void viewShow(PCB pReady, PCB pRun, PCB pBlock,PCB

pFinish)

{

printf(" id time_need time_used status\n");

printf("Ready:

\n");

view(pReady);

printf("Run:

\n");

view(pRun);

printf("Block:

\n");

view(pBlock);

printf("Finish:

\n");

view(pFinish);

printf("\n");

}

//创建若干新的进程(可以不创建进程)

void update_ready(PCB pHead){

PCB p = pHead;

while(p->pNext != NULL) p = p->pNext;

PCB pNew = (PCB)malloc(sizeof(Node));

pNew = fork(random(3));

if (!pNew) return;

else p->pNext = pNew->pNext;

}

//进程调度

void ready_run(PCB pReady,PCB pRun){

PCB p = pReady;

PCB q = pRun;

if(p == NULL) return;

else{

PCB pNew = (PCB)malloc(sizeof(Node));

while(q->pNext != NULL) q = q->pNext;

pNew = p->pNext;

p->pNext = pNew->pNext;

pNew->pNext = NULL;

q->pNext = pNew;

}

}

//时间片到

void timeout(PCB pReady,PCB pRun) {

PCB p = pReady;

PCB q = pRun;

if(q == NULL) return;

else{

PCB pNew = (PCB)malloc(sizeof(Node));

while(p->pNext != NULL) p = p->pNext;

pNew = q->pNext;

q->pNext = pNew->pNext;

pNew->pNext = NULL;

p->pNext = pNew;

}

}

//进程等待事件

void run_block(PCB pRun,PCB pBlock){

PCB p = pRun;

PCB q = pBlock;

if(p == NULL) return;

else {

while(q->pNext != NULL) q = q->pNext;

q->pNext = p->pNext;

p->pNext = NULL;

}

}

//唤醒事件

void Block_ready(PCB pBlock, PCB pReady) {

PCB p = pBlock;

PCB q = pReady;

if(p == NULL) return;

else{

PCB pNew = (PCB)malloc(sizeof(Node));

while(q->pNext != NULL) q = q->pNext;

pNew = p->pNext;

p->pNext = pNew->pNext;

pNew->pNext = NULL;

q->pNext = pNew;

}

}

//进程完成

void run_finish(PCB pRun,PCB pFinish){

PCB p = pRun;

PCB q = pFinish;

if(p == NULL) return;

else{

while(q->pNext != NULL) q = q->pNext;

q->pNext = p->pNext;

p->pNext = NULL;

}

}

//进程就绪

void ready(PCB pReady){

PCB p = pReady->pNext;

while(p != NULL){

p->status = 'r';

p = p->pNext;

}

}

//进程运行

void run(PCB pRun){

PCB p = pRun->pNext;

p->status = 'e';

}

//进程完成

void finish(PCB pFinish){

PCB p = pFinish->pNext;

while(p != NULL){

p->status = 'f';

p = p->pNext;

}

}

//进程等待

void block(PCB pBlock){

PCB p = pBlock->pNext;

while(p != NULL){

p->status = 'b';

p = p->pNext;

}

}

int main(){

PCB pReady,pRun,pBlock,pFinish; //声明就绪，运行，阻塞，完成队列

pReady = pRun = pBlock = pFinish = NULL;

pReady = fork(5);//创建就绪队列

pRun = fork(0);//创建运行队列

pBlock = fork(0);//创建等待队列

pFinish = fork(0);//创建完成队列

viewShow(pReady,pRun,pBlock,pFinish);

LPTime systemtime=0;//初始化时间

systemtime=InitTime(systemtime);

//程序运行，时间开始

for(;;) {

special = random(10);//特殊事件

wakeup = random(5);//唤醒事件

UpdateTime(systemtime);//不断更新时间

if(pReady->pNext == NULL && pRun->pNext == NULL

&& pBlock->pNext == NULL){

exit(1);

}

//每三秒创建若干进程

if(miao % 30 == 0){

update_ready(pReady);

viewShow(pReady,pRun,pBlock,pFinish);

getchar();

}

//运行队列空，就绪队列进程被调度

if(pRun->pNext == NULL && pReady->pNext != NULL

){

ready_run(pReady,pRun);

run(pRun);

viewShow(pReady,pRun,pBlock,pFinish);

getchar();

}

//时间片消耗，6S

if(pRun->pNext != NULL){

pRun->pNext->time_used ;

//时间片耗完

if(pRun->pNext->time_used % 60 == 0){

timeout(pReady,pRun);

ready(pReady);

viewShow(pReady,pRun,pBlock,pFinish);

getchar();

}

//进程完成

if( pRun->pNext->time_used >=

pRun->pNext->time_need){

run_finish(pRun,pFinish);

finish(pFinish);

viewShow(pReady,pRun,pBlock,pFinish);

getchar();

}

}

//特殊事件发生，进程等待事件

if(special == 0 && pRun->pNext != NULL ){

run_block(pRun,pBlock);

block(pBlock);

viewShow(pReady,pRun,pBlock,pFinish);

getchar();

}

//唤醒事件发生，阻塞进程被唤醒

if(wakeup == 1 && pBlock->pNext != NULL){

Block_ready(pBlock,pReady);

ready(pReady);

viewShow(pReady,pRun,pBlock,pFinish);

getchar();

}

Sleep(100);

}

return 0;

}

蜉蝣在人间
关注
计算机操作系统实验之模拟进程管理（C语言）
小姚的博客
10-21 3万+
利用C语言模拟实现操作系统中的进程管理
进程管理 C语言
最新发布
qq_52185773的博客
02-07 732
用C语言实现操作系统进程的创建和删除
c 语言进程管理程序分析,C语言模拟进程管理
weixin_33678821的博客
05-17 402
《C语言模拟进程管理》由会员分享，可在线阅读，更多相关《C语言模拟进程管理(19页珍藏版)》请在人人文库网上搜索。1、操作系统课程设计报告目 录一 需求分析6二 概要设计6三 详细设计(含主要代码)6四 调试分析、测试结果12五 用户使用说明14六 后记14七 参考资料14一 需求分析在多道处理程序运行环境下，进程数目一般多于处理机数目，使得进程要通过竞争来使用处理机。这就要求系统能按照某种算法，...
简单的c语言模拟进程管理实验
04-19
用c语言模拟进程管理 1、首先构建进程的数据结构 2、实现建立进程 3、三种基本状态的队列 4、将进程入队 5、实现进程在队列之间的转换 6、进程通信
进程调度和作业调度算法C语言实现
04-13
本项目通过C语言实现了这些调度算法，旨在帮助理解其工作原理并提供实践操作的机会。 首先，我们关注的是**进程调度**。进程调度主要负责在就绪队列中选择一个进程投入运行。这里涉及到三种常见的调度算法： 1. **...
C语言模拟实现OS地址变换功能
06-26
总的来说，通过C语言模拟OS地址变换功能是一个很好的学习操作系统的实践项目，它涵盖了分页、地址空间、页表操作、内存管理和缺页异常处理等多个核心概念。这个过程不仅有助于理解和实现操作系统的工作原理，也有助...
模拟操作系统 os 进程 设备 磁盘 文件管理实现 比较简单 c 语言版
01-25
在这个“模拟操作系统 os 进程 设备 磁盘 文件管理实现 比较简单 c 语言版”中，我们可以看到一个简化版的操作系统实现，主要关注进程管理、设备管理和文件管理这三个关键领域，所有这些都是使用C语言编写的。...
c语言模拟进程
05-01
内容：设计一个简单的进程调度算法，模拟OS中的进程调度过程 2．要求： ① 进程数不少于5个； ② 进程调度算法任选； 最好选用动态优先数法，每运行一个时间片优先数减3 ③ 用C++（或C）语言编程； ④ 程序运行时...
操作系统进程管理实验（C语言实现）
02-02
操作系统进程管理实验（C语言实现）
操作系统使用C语言链表实现进程管理
03-15
用C语言链表实现进程转换，阻塞变就绪，就绪变执行，执行变阻塞三种状态的转换
进程管理 C语言代码
06-08
本代码是关于进程管理的C语言源代码，适合于做操作系统的实验
进程管理模拟实现
04-08
#include #include "dos.h" #include "stdlib.h" #include "conio.h" //PCB结构体 struct pcb{ int id; //进程序号 int ra; //所需资源A的数量 int rb; //所需资源B的数量 int rc; //所需资源C的数量 int ntime; //所需的时间片个数 int rtime; //已经运行的时间片个数 char state; //进程状态 struct pcb *next; } *hready=NULL,*hblock=NULL,*p; //hready，hblock分别为指向就绪和阻塞队列 typedef struct pcb PCB; int m,n,r,a,b,c,h=0,i=1,time1Inteval; //m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //建立一个PCB结构体型的空链表 PCB *increat(void) { PCB *head=NULL; //head=NULL; return(head); } //从链表起始地址开始输出该链表的内容 void disp(PCB *head) {PCB *p1; p1=head; AnsiString str2; if(head!=NULL) //链表非空 { do { str2+=" "; str2+=IntToStr(p1->id);str2+=" "; str2+=(p1->state);str2+=" "; str2+=IntToStr(p1->ra);str2+=" "; str2+=IntToStr(p1->rb);str2+=" "; str2+=IntToStr(p1->rc);str2+=" "; str2+=IntToStr(p1->ntime);str2+=" "; str2+=IntToStr(p1->rtime);str2+="\r\n"; p1=p1->next; }while(p1!=NULL); //不断输出进程的信息，直到链尾！ } //if else { str2+="\t\t该 队 列 中 没 有 进 程！\r\n" ;} Form1->Memo1->Lines->Add(str2); } //将进程插入到链尾（包括就绪队列和阻塞队列） PCB *insert(PCB *head,PCB*pcb) //带两个指针形参：队列指针和当前进程PCB { PCB *pi,*p1; p1=head; pi=pcb; if (head==NULL) { head=pi; pi->next=NULL; } else { while(p1->next!=NULL) {p1=p1->next;} p1->next=pi; pi->next=NULL; } return(head); } //对进程进行初始化，建立就绪队阻塞队列。 void input() { AnsiString str1; m=StrToInt (Form1->Edit1->Text); //读取要模拟的进程总数给m n=StrToInt (Form1->Edit2->Text); //读取需初
模拟进程管理系统
06-25
本程序为模拟进程管理系统，并设计MFC界面，系统内包含银行家算法、FIFO算法、短作业优先算法和优先级优先算法，进程可自由创建，并可以进行进程的单步运行、阻塞唤醒操作，显示界面分3部分，分别为就绪进程、阻塞进程和全部进程。环境为VS 2015，没有引入其他包。
C语言——进程管理
塔通天的博客
01-31 2142
文章目录进程基本概念进程的属性进程控制相关函数进程创建进程等待进程结束多个进程间的关系进程组时间片分配调度策略和参数优先级设定进程同步线程线程的创建线程结束、挂起、取消互斥 进程基本概念 进程是具有一定功能的程序关于一个数据集合的一次执行过程。Linux系统支持多个进程同时进行，每个进程属性中的安全信息里都设定有一个优先级，系统根据优先级来决定各个进程从CPU获得的时间片的大小。 Linux内核把进程成为任务（task），进程的虚拟地址空间分为用户虚拟地址空间和内核虚拟地址空间，所有进程个共享内核虚拟地址空
c实现进程管理(链表)
Tisnum的博客
03-30 1792
#include <stdio.h> #include <stdlib.h> struct Jincheng{ int pid; int priority; //优先级 int size; int state; //标志进程状态，0为不在内存 1为内存 2为挂起 char info[20]; struct Jincheng *next; }; int index = 0; Jincheng *yunxing,*guaqi; //打印链
c语言进程管理程序
reg183的专栏
11-16 941
代码如下 #include "stdafx.h" #include<windows.h> #include<tlhelp32.h> #include<string> #include <iostream> using namespace std; int KillProcess(DWORD pid){ HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pid); if (hProcess.
linux进程管理（C语言）
yin_wuzhe的专栏
03-08 1858
理解进程控制的原理对于理解和修改fio project非常的重要。"fio is an I/O tool meant to be used both for benchmark and stress/hardware verification."
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值