模拟进程调度

最新推荐文章于 2024-10-02 08:00:00 发布
最新推荐文章于 2024-10-02 08:00:00 发布
阅读量187 收藏
点赞数
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Max316121/article/details/128189969
版权 

using namespace std;
#include <iostream>
#include <bits/stdc++.h>
#include<math.h>
#include<queue>

struct Node {
    string a;
    int arr;             //到达时间
    int need;               //需要时间
    int done=0;               //已占用CPU时间
    int priority;           //优先级
    char status='U';                 //进程状态 有R W U三种分别为运行 等待 未到达,其实就是个标记，反正不会显示 

};

Node in[11];
int n;
int Time = 0;
int finish = 0;
int pNum = 0;//已到达的数量
Node pre[11];
double ans1 = 0;
double ans2 = 0;

bool cmp(Node x, Node y)
{
    return x.arr < y.arr;
}
bool cmpP(Node x, Node y)
{
    return x.priority > y.priority;
}
bool cmpSJF(Node x, Node y)
{
    return x.need < y.need;
}
void init() {
    
    cout << "\t请输入进程个数(最大10个)  ";
    cin >> n;
    cout << "\t请输入 进程名称 到达时间 运行时间 优先级" << endl;
    for (int k = 1;k <= n;k++) { cout << "\t";cin >> in[k].a >> in[k].arr >> in[k].need >> in[k].priority; }
    sort(in+1,in+n+1,cmp);
    cout << "\n\n";
}
void runtable() {//by Max
    for (int k = 1;k <= pNum;k++) {
        if (pre[k].status == 'R')
            cout << "本次运行结果：\n\t" << pre[k].a << "\t" << pre[k].arr << "\t" << pre[k].need << "\t" << pre[k].done << "\t" << pre[k].priority << "\t" << "运行\n\n" << endl;
    }
}
void pretable() {
	
    cout << "  进程名称 到达时间 所需时间 已运行时间 优先级 当前状态" << endl;
    for (int k = 1;k <= pNum;k++) {
        
        if (pre[k].status == 'R') cout << "\t" << pre[k].a << "\t" << pre[k].arr << "\t" << pre[k].need << "\t" << pre[k].done << "\t" << pre[k].priority << "\t" << "运行" << endl;
        else if (pre[k].status == 'W') cout << "\t" << pre[k].a << "\t" << pre[k].arr << "\t" << pre[k].need << "\t" << pre[k].done << "\t" << pre[k].priority << "\t" << "等待" << endl;
        
    }
}

void PSA() {
    while (finish<n) {//完成个数小于总个数
        finish = 0;
        for (int k = 1;k <= n;k++) {//循环一遍，将准备好的进程复制到新数组,没有的话就将time++再来一次
            if (in[k].arr == Time&&in[k].status=='U') { in[k].status = 'W';pre[pNum + 1] = in[k];pNum++; }
            if (pNum - finish <= 0) { Time++; k = 0;continue; }
        }
        sort(pre + 1, pre + 1 + pNum, cmpP);//将pre数组准备好的进程按照优先级排列
        for (int k = 1;k <= pNum;k++) {
            if (pre[k].done == pre[k].need)finish++;
            if (pre[k].done < pre[k].need) {
                pre[k].status = 'R';
                cout << "  *****************************************************" << endl;
                cout << "\n当前时刻为：" << Time<<endl;
                pretable();
                pre[k].done++;
                runtable();
                Time++;
                pre[k].status = 'W';
                if (pre[k].done == pre[k].need) { pre[k].status = 'F'; ans1 += (Time - pre[k].arr);ans2 += (double)(Time - pre[k].arr) / (double)pre[k].need;
                }
                break;
            }
        }
    }
    cout << "\n\t\t***********";
    cout << "\n\t\t运行结束";
    cout << "\n\t\t平均周转时间为：" << ans1 / n;
    cout << "\n\t\t平均带权周转时间为：" << ans2 / n;
    
}
void FCFS() {
    while (finish < n) {//完成个数小于总个数
        finish = 0;
        for (int k = 1;k <= n;k++) {//循环一遍，将准备好的进程复制到新数组,没有的话就将time++再来一次
            if (in[k].arr == Time && in[k].status == 'U') { in[k].status = 'W';pre[pNum + 1] = in[k];pNum++; }
            if (pNum - finish <= 0) { Time++; k = 0;continue; }
        }
        for (int k = 1;k <= pNum;k++) {
            if (pre[k].done == pre[k].need)finish++;
            if (pre[k].done < pre[k].need) {
                pre[k].status = 'R';
                cout << "\n当前时刻为：" << Time<<endl;
                pretable();
                pre[k].done++;			//已运行时间+1 
                runtable();
                Time++;					//时间片+1 
                pre[k].status = 'W';	//重新等待ing 
                if (pre[k].done == pre[k].need) { pre[k].status = 'F'; ans1 += (Time - pre[k].arr);ans2 += (double)(Time - pre[k].arr)/ (double)pre[k].need;
                }
                break;
            }
        }
    }
    cout << "\n\t\t***********";
    cout << "\n\t\t运行结束";
    cout << "\n\t\t平均周转时间为：" << ans1 / n;
    cout << "\n\t\t平均带权周转时间为：" << ans2 / n;
}

void MFQ() {
    queue<Node> q1;
    queue<Node> q2;
    queue<Node> q3;
   
    Node temp;
    Node x;
   
    while ((!q1.empty() || !q2.empty() || !q3.empty()) || Time <= in[n].arr) {//完成个数小于总个数
        finish = 0;
        for (int k = 1;k <= n;k++) {//循环一遍，将准备好的进程复制到新数组,没有的话就将Time++再来一次
            if (in[k].arr == Time && in[k].status == 'U') { in[k].status = 'W';q1.push(in[k]); }
            if (q1.empty() && q2.empty() && q3.empty()) { Time++; continue; }
        }
        
        if (!q1.empty()) {
            x = q1.front();
            if (x.done < x.need) {
                x.status = 'R';
                cout << "\n第一队列：";
                cout << "\n当前时刻为：" << Time << endl;
                //此处添加函数 将队列转化为数组输出
                pNum = q1.size();pre[1] = x;q1.push(x);q1.pop();
                for (int kk = 2;kk <= q1.size();kk++) {
                    temp = q1.front();
                    pre[kk] = temp;
                    q1.push(temp);
                    q1.pop();
                }
                pretable();
                x.done++;
                pre[1].done++;
                runtable();
                Time++;
                x.status = 'W';
                if (x.done == x.need) {
                    q1.pop();
                    ans1 += (Time - x.arr);ans2 += (double)(Time - x.arr) / (double)x.need;
                }
                else {
                    q2.push(x);
                    q1.pop();
                }
            }
        }
        if (q1.empty() && !q2.empty()) {
            x = q2.front();
            if (x.done < x.need) {
                int flag = 0;
                for (int kk = 1;kk <= 2;kk++) {
                    x.status = 'R';
                    cout << "\n第二队列：";
                    cout << "\n当前时刻为：" << Time << endl;
                    //此处添加函数 将队列转化为数组输出
                    pNum = q2.size();pre[1] = x;q2.push(x);q2.pop();
                    for (int kk = 2;kk <= q2.size();kk++) {
                        temp = q2.front();
                        pre[kk] = temp;
                        q2.push(temp);
                        q2.pop();
                    }
                    pretable();
                    x.done++;
                    pre[1].done++;
                    runtable();
                    Time++;
                    x.status = 'W';
                    if (x.done == x.need) {
                        break;
                    }
                    for (int k = 1;k <= n;k++) if (in[k].arr == Time && in[k].status == 'U')  flag = 1;
                    if (flag == 1) {
                        break;
                    }
                }
                if (flag == 1) {
                    q2.push(x);
                    q2.pop();
                    continue;
                }
                if (x.done == x.need) {
                    ans1 += (Time - x.arr);ans2 += (double)(Time - x.arr )/ (double)x.need;
                    q2.pop();
                }
                else {
                    q3.push(x);
                    q2.pop();
                }
            }
        }//第er队列结束，第三队列开始
        if (q1.empty() && q2.empty() && !q3.empty()) {
            x = q3.front();
            int flag = 0;
            for (int kk = 1;kk <= 3;kk++) {
                x.status = 'R';
                cout << "\n第三队列：";
                cout << "\n当前时刻为：" << Time << endl;
                //此处添加函数 将队列转化为数组输出
                pNum = q3.size();pre[1] = x;q3.push(x);q3.pop();
                for (int kk = 3;kk <= q3.size();kk++) {
                    temp = q3.front();
                    pre[kk] = temp;
                    q3.push(temp);
                    q3.pop();
                }
                pretable();
                x.done++;
                pre[1].done++;
                runtable();
                Time++;
                x.status = 'W';
                if (x.done == x.need) {
                    break;
                }
                for (int k = 1;k <= n;k++) if (in[k].arr == Time && in[k].status == 'U')  flag = 1;
                if (flag == 1) {
                    break;
                }
            }
            if (flag == 1) {
                q3.push(x);
                q3.pop();
                continue;
            }
            if (x.done == x.need) {
                ans1 += (Time - x.arr);ans2 += (double)(Time - x.arr )/ (double)x.need;
                q3.pop();
            }
            else {
                q3.push(x);
                q3.pop();
            }
        }
    }
    cout << "\n\t\t***********";
    cout << "\n\t\t运行结束";
    cout << "\n\t\t平均周转时间为：" << ans1 / n;
    cout << "\n\t\t平均带权周转时间为：" << ans2 / n;
}

void SJF() {
    while (finish < n) {//完成个数小于总个数
        finish = 0;
        for (int k = 1;k <= n;k++) {//循环一遍，将准备好的进程复制到新数组,没有的话就将time++再来一次
            if (in[k].arr == Time && in[k].status == 'U') { in[k].status = 'W';pre[pNum + 1] = in[k];pNum++; }
            if (pNum - finish <= 0) { Time++; k = 0;continue; }
        }
        sort(pre + 1, pre + 1 + pNum, cmpSJF);//将pre数组准备好的进程按照短到长级排列
        for (int k = 1;k <= pNum;k++) {
            if (pre[k].done == pre[k].need)finish++;
            if (pre[k].done < pre[k].need) {
                pre[k].status = 'R';

                cout << "\n当前时刻为：" << Time << endl;
                pretable();
                pre[k].done++;
                runtable();
                Time++;
                pre[k].status = 'W';
                if (pre[k].done == pre[k].need) {
                    pre[k].status = 'F'; ans1 += (Time - pre[k].arr);ans2 += (double)(Time - pre[k].arr )/ (double)pre[k].need;
                }
                break;
            }
        }
    }
    cout << "\n\t\t***********";
    cout << "\n\t\t运行结束";
    cout << "\n\t\t平均周转时间为：" << ans1/ n;
    cout << "\n\t\t平均带权周转时间为：" << ans2 / n;

}
int main()
{
    int menu;
    int t = 1;
    printf("\n                          ------------------\n");
    printf("                          |                |\n");
    printf("                          |进程调度模拟实验|           \n");
    printf("                          |                |\n");
    printf("                          ------------------\n\n");
    printf("        |1:PSA\n");
    printf("        |2:FCFS\n");
    printf("        |3:MFQ\n");
    printf("        |4:SJF\n");
    printf("        |其他任意键:退出\n");
    printf("        |那么您的选择是---> ");
    cin >> menu;
    while(t--)
    if (menu == 1) {
        init();//初始化 
        PSA();
    }
    else if (menu==2) {
        init();
        FCFS();
    }
    else if (menu==3) {
        init();
        MFQ();
    }
    else if (menu==4) {
        init();
        SJF();
    }
    else {
        cout << "输入错误" << endl;
    }
    return 0;
}

Max316121
关注
c++实现进程调度的模拟
04-22
利用c++模拟进程的调度。模拟操作系统内核对进程的控制和管理：包括进程的创建和撤销、进程状态的切换和简单的内存空间管理。  能够模拟进程的创建与撤销过程；（4 分）  对进程的状态进行全面的控制；（4 分）  按先进先出方式管理就绪和阻塞队列，按队列输出进程状态 （2 分）  完成可变分区的分配与回收 （3 分）  界面清晰友好 （2 分）  实验结束后撰写实验报告（5 分）。
进程调度模拟
Lym Xin 的博客
11-09 557
实验平台：windows 7,vs2010 实验目标：模拟短作业优先算法，时间片轮转算法，和优先数算法，并动态画出Grant图，计算每个进程的响应时间和周转时间
实验5：进程调度算法模拟-RR
weixin_52357218的博客
01-09 502
计算机操作系统 实验5：进程调度算法模拟-RR 河南大学软件学院
进程调度算法
sheasqq的博客
01-02 485
进程调度算法 操作系统课程设计 武汉理工大学
C/C++实现操作系统进程调度算法，FCFS, RR, SPN, SRT, HRRN
crazybobo1207的博客
10-02 890
进程信息定义在方法InitProcedureInfo中，包括：procedureID（进程ID）, arriveTime（进程到达时间）, serviceTime（服务时间）, eclapsedTime（已服务时间）, remainTime（剩余服务时间）, accumulateTime（累计服务时间）。本程序的优点在于，一旦实现了其中一个调度算法，比如实现了最基本的FCFS之后，只要增加一个排序逻辑，即在重载
操作系统模拟进程调度算法C#Winfrom实现
12-25
在这个C# Winform实现的操作系统模拟进程调度算法项目中，我们将探讨三种基本的调度策略：先来先服务（FCFS）、短作业优先（SJF）和优先级调度。 **先来先服务（FCFS）调度算法**是最简单的调度策略，它按照进程...
jinchengdiaodu.rar_模拟进程调度_调度_调度算法_进程调度模拟
09-21
"jinchengdiaodu.rar"中的内容聚焦于模拟进程调度，这是一个重要的实践和教学工具，用于理解和分析不同的调度算法。 首先，我们要了解进程调度的目标：提高系统吞吐量、减少平均周转时间、减小进程等待时间以及保持...
OS.zip_os_模拟进程调度_进程调度
09-23
本实验“OS.zip_os_模拟进程调度_进程调度”旨在通过模拟进程调度算法来帮助我们深入理解这一概念。 首先，我们需要了解进程和线程的基本概念。进程是程序在执行过程中的一个实例，拥有独立的内存空间，而线程是...
操作系统课设--基于python的模拟进程调度源码.zip
10-26
-基于python的模拟进程调度源码.zip操作系统课设--基于python的模拟进程调度源码.zip操作系统课设--基于python的模拟进程调度源码.zip操作系统课设--基于python的模拟进程调度源码.zip操作系统课设--基于python的...
操作系统实验-模拟进程调度
05-14
本实验——"操作系统实验-模拟进程调度"旨在通过模拟来深入理解这一核心概念。 进程调度是操作系统内核中的一个关键组件，其主要职责是决定哪个进程应该获得CPU执行权。调度算法的选择直接影响到系统的吞吐量、周转...
模拟文件系统的设计与实现
刘映辰的博客
06-10 6887
模拟文件系统的实现的基本功能，了解文件系统的基本结构和文件系统的管理方法,加深了解文件系统的内部功能的实现。通过高级语言编写和实现一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作系统命令的实质内容和执行过程有比较深入的了解。通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。 本文是在学习完操作系统课程后所完成的课程设计，文中就模拟文件管理系统进行了简单的研究。文件系统的目录结构采用类似 Linux 的树状结构。 在此文件管理系统中,可实现的操作有: 改变
进程模拟调度实验
weixin_46696469的博客
04-06 5503
实验三 进程模拟调度实验 一、实验目的 多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机，本实验模拟实现处理机调度，以加深了解处理机调度的工作 二、实验内容 选择一个调度算法，实现处理机调度。 三、实验要求 1、设计一个按下面三种调度算法实现处理机调度的程序。 1）先来先服务 2）短进程优先或优先权高优先 3）按时间片轮转 2、说明：PCB内容： 进程名/PID 、要求运行时间（单位时间）、优先权、状态 、到达时间、已用CPU时间等。 1） 可随机输入.
“进程调度模拟程序”实验报告
m0_64286728的博客
06-06 5756
进程调度模拟程序的设计，包括以下2种调度算法：采用优先数调度算法的模拟进程调度程序、采用时间片轮转调度算法的模拟进程调度程序。
操作系统课程设计进程调度模拟
m0_56241309的博客
11-10 4019
进程调度模拟
【c++】用c++实现简单的进程调度程序
离光曦的博客
09-20 2940
模拟linux实现了基本的资源仓库、进程池、资源申请、资源释放、创建进程、进程调度（多级反馈调度）、进程撤销、时间中断和一个简单的脚本。一个课程实验，很多bug、不完善，只是为了模拟进程调度算法，所以不是真实的申请资源（资源也是模拟的），甚至可以说是just for fun吧，将就着看。个人觉得，这种程序自己写一遍可以加深印象，但不要强求完善，这不是一朝一夕的事，也没有必要，要知道linux的进程...
几种进程调度算法模拟C++实现
A_Bo的博客
06-05 1万+
先到先服务（FCFS）
操作系统实验之一--进程调度算法的模拟实现
热门推荐
一个简单的博客
01-11 1万+
发一些大三操作系统的实验代码吸引阅读量吧，当时做实验的时候看见网上很多人写的代码并不好，而且很多人都有错误的地方。如果好的话希望能点赞关注。 常见的进程调度算法有：先来先服务 （FCFS，first come first served） 、最短作业优先（SJF, Shortest Job First） 、 时间片轮转算法（RR，Round-Robin） 、多级反馈队列(Multilevel
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1700
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
操作系统综合设计：模拟进程调度功能实现
"这篇综合设计报告是关于模拟进程调度功能的设计与实现，由武汉工程大学计算机科学与工程学院的学生在2011年进行。报告涵盖了设计过程、实现细节以及评估标准，旨在模拟操作系统中的进程调度机制。" 在操作系统中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值