计算机操作系统实验：模拟进程状态转换程序

最新推荐文章于 2024-07-23 14:16:29 发布
最新推荐文章于 2024-07-23 14:16:29 发布
阅读量4.4k 收藏 75
点赞数 8
分类专栏： 计算机操作系统 进程 文章标签： 操作系统 算法 队列 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44150242/article/details/103929567
版权

实验：模拟进程状态转换程序

一、实验内容完成情况（请写明自己已完成的项目功能）：

  1. 完成进程控制块结构体的编写
  2. 创建就绪队列、阻塞队列、运行队列、完成队列、挂起队列
  3. 初始化操作系统的原始进程：可静态设置也可动态添加
  4. 编写新建进程函数
  5. 系统开始调度
  6. 当前运行进程请求 I/O 事件
  7. 某进程 I/O 完成
  8. 时间片到期
  9. 其他阻塞事件
  10. 挂起
  11. 完成先来先服务算法
  12. 完成优先级调度算法
  13. 完成时间片轮转算法
  14. 查看当前所有进程的 PCB 信息
  15. 查看当前时刻就绪队列和阻塞队伍信息
  16. 查看当前正在运行的进程信息
  17. 计算当前时刻，每个进程的周转时间。

三、模块说明及相应代码：
1、 初始化操作系统（请文字写明思路并给出核心代码）：
1） 创建PCB的结构体:
思路：根据实验要求完成结构体的创建
代码：
typedef struct node
{
char name[20]; //进程名
int id = 0; //进程ID
int priority = 0; //优先级
int ArriTime = 0; //进程到达时间
int serviceTime=0; //进程总需要时间
int needTime = 0; //还需要运行时间
int CPUTime = 0; //已用CPU时间
char state[20]; //进程状态 1.Ready 2.Run 3.Wait 4.Finish
int finishTime = 0; //完成时间
char blockCause[30]; //阻塞原因
int aroundTime=0; //周转时间
} PCB;
2） 创建就绪队列、阻塞队列、运行队列：采用队列的方式/其他方式也可以
思路：用队列的方式
代码：
queue processQueue, readyQueue, blockQueue, runQueue, finishQueue,hungQueue;//临时队列、就绪队列、阻塞队列、运行队列、完成队列、挂起队列
3）编写创建进程函数：
思路：分为手动输入还是自动输入，手动输入为用户自己创建，自动输入为调入我自己初始化的进程。
代码：
//初始化进程
void Init()
{
PCB p1, p2, p3,p4,p5;
strcpy(p1.name, “a”);
p1.id = 1;
p1.priority = 8;
p1.ArriTime = 2;
p1.needTime = 4;
p1.serviceTime=4;
processQueue.push(p1);
strcpy(p2.name, “b”);
p2.id = 2;
p2.priority = 4;
p2.ArriTime = 6;
p2.needTime = 4;
p2.serviceTime=4;
processQueue.push(p2);
strcpy(p3.name, “c”);
p3.id = 3;
p3.priority = 7;
p3.ArriTime = 3;
p3.needTime = 9;
p3.serviceTime=9;
processQueue.push(p3);
strcpy(p4.name, “d”);
p4.id = 4;
p4.priority = 1;
p4.ArriTime = 0;
p4.needTime = 1;
p4.serviceTime=1;
processQueue.push(p4);
strcpy(p5.name, “e”);
p5.id = 5;
p5.priority = 2;
p5.ArriTime = 2;
p5.needTime = 2;
p5.serviceTime=2;
processQueue.push(p5);
}

//添加进程
void addProcess()
{
int n;
cout << “请输入要添加的进程数：” << endl;
cin >> n;
for (int i = 0; i < n; i++)
{
PCB p;
cout << “请输入第”<<i+1<<“个进程名、进程优先级、进程到达时间、进程需要运行时间:” << endl;
cin >> p.name>>p.priority>> p.ArriTime>> p.serviceTime;
p.id=i+1;
p.needTime=p.serviceTime;
processQueue.push§;
}
}
2、 进程在其生命周期的都处于不断变换的过程，处理至少四种事件：（请文字写明思路并给出核心代码）

  1. 设置调度算法
    思路：设置菜单，让用户自己选择使用算法，设置调度算法。
    代码：
    int e;
    cout << “请输入算法” << endl;
    cout << “1.先来先服务 2.优先级抢占 3.时间片轮转” << endl;
    cin >> e;
    switch (e)
    {
    case 1:
    FCFS();
    break;
    case 2:
    SJF();
    break;
    case 3:
    RR();
    break;
    }
  2. 调度开始
    思路：调度开始，程序先判断运行队列是否为空，如果为空，就将就绪队列的队头元素压入运行队列中，如果就绪队列为空，则判断阻塞队列是否为空，再判断挂起队列是否为空，若都为空则结束程序。
    代码：
    //系统开始调度
    void beginDispatch()
    {
    if (runQueue.empty())
    {
    if (!readyQueue.empty())
    {
    strcpy(readyQueue.front().state,“Run”);
    runQueue.push(readyQueue.front());
    readyQueue.pop();
    runQueue.front().CPUTime++;
    runQueue.front().needTime–;
    time++;
    }
    else if(!blockQueue.empty())
    {
    char chance=‘p’;
    cout<<endl;
    cout<<“就绪队列不为*************”<<endl;
    cout<<“若结束序请按y,若不结束请按n"<<endl;
    cin>>chance
    if(chance=‘y’)
    {
    finish = true;
    return;
    }
    }
    else if(!hungQueue.empty())
    {
    char chance=‘p’;
    cout<<endl;
    cout<<"挂起队列不为空    ***********”<<endl;
    cout<<"**若结束程序请按y,若不结束请按n"<<endl;
    cin>>chance;
    if(chance==‘y’)
    {
    finish = true;
    return;
    }
    }
    else
    {
    finish = true;
    return;
    }
    }
    else if (!runQueue.empty())
    {
    if (runQueue.front().needTime == 0)
    {
    runQueue.front().finishTime = time;
    strcpy(runQueue.front().state,“Finish”);
    finishQueue.push(runQueue.front());
    runQueue.pop();
    if (!readyQueue.empty())
    {
    strcpy(readyQueue.front().state,“Run”);
    runQueue.push(readyQueue.front());
    readyQueue.pop();
    }
    }
    //先来先服务
    if (algorithm == 1)
    {
    time++;
    runQueue.front().CPUTime++;
    runQueue.front().needTime–;
    }
    //优先级
    if (algorithm == 2)
    {
    time++;
    runQueue.front().CPUTime++;
    runQueue.front().needTime–;
    }
    //时间片轮转算法
    if(algorithm == 3)
    {
    time++;
    runQueue.front().CPUTime++;
    runQueue.front().needTime–;
    if (runQueue.front().needTime != 0)
    {
    if ((runQueue.front().CPUTime >= timeslice) &&(runQueue.front().CPUTime % timeslice == 0))
    {
    strcpy(runQueue.front().state,“Ready”);
    readyQueue.push(runQueue.front());
    runQueue.pop();
    if (!readyQueue.empty())
    {
    strcpy(readyQueue.front().state,“Run”);
    runQueue.push(readyQueue.front());
    readyQueue.pop();
    }
    }
    }
    }
    }
  3. CPU运行时间
    思路：用一个全局变量time计算CPU的运行时间，每运行一次time++；
  4. I/O事件
    思路：若用户在菜单键选择请求I/O事件，先判断运行队列是否为空，若为空则提示当前无进程运行，反之则将当前正在运行的进程压入阻塞队列，状态改为“wait”，阻塞原因改为“请求I/O事件”。
    代码：
    //当前运行进程请求 I/O 事件
    void IORequest()
    {
    if (!runQueue.empty())
    {
    if (runQueue.front().needTime != 0)
    {
    strcpy(runQueue.front().blockCause, “请求 I/O 事件”);
    strcpy(runQueue.front().state,“Wait”);
    blockQueue.push(runQueue.front());
    runQueue.pop();
    }
    }
    else
    {
    cout << “当前无运行进程” << endl;
    }
    }
  5. I/O完成
    思路：若用户在菜单键选择I/O完成，先判断阻塞队列是否为空，若为空则提示当前无进程阻塞，反之用户输入I/O完成的队列的id，遍历一遍阻塞队列中id与输入id匹配的进程，则将当前正在运行的进程压入阻塞队列，状态改为“wait”，阻塞原因改为“请求I/O事件”。
    代码：
    //某进程I/O完成
    void IOFinish()
    {
    //空
    if (blockQueue.empty())
    {
    cout << “目前无阻塞进程” << endl;
    }
    //不空
    else
    {
    int id;
    cout << “请输入I/O完成的进程ID” << endl;
    cin >> id;
    for (int i = 0; i < blockQueue.size(); i++)
    {
    if (blockQueue.front().id == id)
    {
    strcpy(blockQueue.front().blockCause, " ");
    strcpy(blockQueue.front().state,“Ready”);
    readyQueue.push(blockQueue.front());
    blockQueue.pop();
    if (algorithm == 1)//先来先服务
    {
    //排序
    PCB temp[readyQueue.size()];
    int n = 0;
    while (!readyQueue.empty())
    {
    temp[n] = readyQueue.front();
    readyQueue.pop();
    n++;
    }
    sort(temp, temp + n, cmp1());
    for (int i = 0; i < n; i++)
    {
    readyQueue.push(temp[i]);
    }
    }
    if (algorithm == 2)//优先级
    { if (algorithm == 1)//先来先服务
    {
    //排序
    PCB temp[readyQueue.size()];
    int n = 0;
    while (!readyQueue.empty())
    {
    temp[n] = readyQueue.front();
    readyQueue.pop();
    n++;
    }
    sort(temp, temp + n, cmp1());
    for (int i = 0; i < n; i++)
    {
    readyQueue.push(temp[i]);
    }
    //排序
    PCB temp[readyQueue.size()];
    int n = 0;
    while (!readyQueue.empty())
    {
    temp[n] = readyQueue.front();
    readyQueue.pop();
    n++;
    }
    sort(temp, temp + n, cmp2());
    for (int i = 0; i < n; i++)
    {
    readyQueue.push(temp[i]);
    }
    }
    if (algorithm == 3)//时间片轮转
    {
    //排序
    PCB temp[readyQueue.size()];
    int n = 0;
    while (!readyQueue.empty())
    {
    temp[n] = readyQueue.front();
    readyQueue.pop();
    n++;
    }
    for (int i = 0; i < n; i++)
    {
    readyQueue.push(temp[i]);
    }
    }
    }
    else
    {
    blockQueue.push(blockQueue.front());
    blockQueue.pop();
    }
    }
    }
    3写函数查看当前系统状态：（请文字写明思路并给出核心代码）
  6. 如何查看系统信息
    思路：打印相应队列中的信息
    代码：
    //显示就绪队列
    void displayReady()
    {
    cout << “----------------就绪队列----------------” << endl;
    queue temp = readyQueue;
    while (!temp.empty())
    {
    if(algorithm == 1)
    {
    cout << “进程名” <<" 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 2)
    {
    cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 3)
    {
    cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” "<<temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    }

}
//显示运行队列
void displayRun()
{
cout << “----------------运行队列----------------” << endl;
queue temp = runQueue;
while (!temp.empty())
{
if(algorithm == 1)
{
cout << “进程名” <<" 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 2)
{
cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 3)
{
cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
temp.pop();
cout << endl;
}
}
}
}
//显示阻塞队列
void displayBlock()
{
cout << “----------------阻塞队列----------------” << endl;
queue temp = blockQueue;
while (!temp.empty())
{
if(algorithm == 1)
{
cout << “进程名” <<” 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 阻塞原因"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<” “<<temp.front().blockCause<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 2)
{
cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 阻塞原因"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<” “<<temp.front().blockCause<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 3)
{
cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 阻塞原因"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<” “<<temp.front().blockCause<<endl;
temp.pop();
cout << endl;
}
}
}
}
//显示完成队列
void displayFinish()
{
cout << “----------------完成队列----------------” << endl;
queue temp = finishQueue;
while (!temp.empty())
{
if(algorithm == 1)
{
cout << “进程名” <<” 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 完成时间"<< " 周转时间"<< " 状态"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<< temp.front().finishTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 2)
{
cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 完成时间"<< " 状态"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().finishTime<<” “<< temp.front().state<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 3)
{
cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 完成时间"<< " 状态"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().finishTime<<” "<<temp.front().state<<endl;
temp.pop();
cout << endl;
}
}
}

}
//显示挂起队列
void displayHung()
{
cout << “----------------挂起队列----------------” << endl;
queue temp = hungQueue;
while (!temp.empty())
{
if(algorithm == 1)
{
cout << “进程名” <<" 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 挂起原因"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<” “<<temp.front().blockCause<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 2)
{
cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 挂起原因"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<” “<<temp.front().blockCause<<endl;
temp.pop();
cout << endl;
}
}
if(algorithm == 3)
{
cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 挂起原因"<< endl;
while (!temp.empty())
{
cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<” "<<temp.front().blockCause<<endl;
temp.pop();
cout << endl;
}
}
}
}
2) 周转时间的计算。
思路：周转事件=完成时间-到达时间。
代码：
temp.front().finishTime-temp.front().ArriTime

3、 需要实现的调度算法：（请文字写明思路并给出核心代码）

  1. 先来先服务调度算法
    思路：详细过程在见开始调度algorithm == 1。
    代码：
    void FCFS()
    {
    algorithm = 1;
    PCB temp[processQueue.size()];
    int n = 0;
    while (!processQueue.empty())
    {
    temp[n] = processQueue.front();
    processQueue.pop();
    n++;
    }
    sort(temp, temp + n, cmp1());
    for (int i = 0; i < n; i++)
    {
    strcpy(temp[i].state,“Ready”);
    readyQueue.push(temp[i]);
    }
    }

  2. 时间片轮转调度算法
    思路：详细过程在见开始调度algorithm == 3。
    代码：
    //时间片轮转
    void RR()
    {
    cout << “请输入时间片大小” << endl;
    cin >> timeslice;
    algorithm = 3;
    readyQueue = processQueue;
    for (int i = 0; i < readyQueue.size(); i++)
    {
    strcpy(readyQueue.front().state,“Ready”);
    readyQueue.push(readyQueue.front());
    readyQueue.pop();
    }
    }

  3. 优先级调度算法
    思路：详细过程在见开始调度algorithm == 2。
    代码：
    //优先级调度算法
    void SJF()
    {
    algorithm = 2;
    PCB temp[processQueue.size()];
    int n = 0;
    while (!processQueue.empty())
    {
    temp[n] = processQueue.front();
    processQueue.pop();
    n++;
    }
    sort(temp, temp + n, cmp2());
    for (int i = 0; i < n; i++)
    {
    strcpy(temp[i].state,“Ready”);
    readyQueue.push(temp[i]);
    }
    }

完整的代码献上：

#include <iostream>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;
const int MAXN = 1000; //假设能够容纳的进程最多的个数
typedef struct node
{
    char name[20];       //进程名
    int id = 0;          //进程ID
    int priority = 0;    //优先级
    int ArriTime = 0;    //进程到达时间
    int serviceTime=0;   //进程总需要时间
    int needTime = 0;    //还需要运行时间
    int CPUTime = 0;     //已用CPU时间
    char state[20];       //进程状态 1.Ready 2.Run 3.Wait 4.Finish
    int finishTime = 0;  //完成时间
    char blockCause[30]; //阻塞原因
    int aroundTime=0;    //周转时间
} PCB;

queue<PCB> processQueue, readyQueue, blockQueue, runQueue, finishQueue,hungQueue;
int time = 0;      //系统时间
int algorithm = 0; //算法选择标志
int timeslice = 0; //时间片大小
bool finish;       //是否完成

struct cmp1
{
    bool operator()(const PCB &p1, const PCB &p2)
    {
        return p1.ArriTime < p2.ArriTime; //到达时间从小到大排序
    }
};

struct cmp2
{
    bool operator()(const PCB &p1, const PCB &p2)
    {
        return p1.priority > p2.priority; //优先级从大到小排序
    }
};

//初始化进程
void Init()
{
    PCB p1, p2, p3,p4,p5;
    strcpy(p1.name, "a");
    p1.id = 1;
    p1.priority = 8;
    p1.ArriTime = 2;
    p1.needTime = 4;
    p1.serviceTime=4;
    processQueue.push(p1);
    strcpy(p2.name, "b");
    p2.id = 2;
    p2.priority = 4;
    p2.ArriTime = 6;
    p2.needTime = 4;
    p2.serviceTime=4;
    processQueue.push(p2);
    strcpy(p3.name, "c");
    p3.id = 3;
    p3.priority = 7;
    p3.ArriTime = 3;
    p3.needTime = 9;
    p3.serviceTime=9;
    processQueue.push(p3);
    strcpy(p4.name, "d");
    p4.id = 4;
    p4.priority = 1;
    p4.ArriTime = 0;
    p4.needTime = 1;
    p4.serviceTime=1;
    processQueue.push(p4);
    strcpy(p5.name, "e");
    p5.id = 5;
    p5.priority = 2;
    p5.ArriTime = 2;
    p5.needTime = 2;
    p5.serviceTime=2;
    processQueue.push(p5);
}

//添加进程
void addProcess()
{
    int n;
    cout << "请输入要添加的进程数：" << endl;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        PCB p;
        cout << "请输入第"<<i+1<<"个进程名、进程优先级、进程到达时间、进程需要运行时间:" << endl;
        cin >> p.name>>p.priority>> p.ArriTime>> p.serviceTime;
        p.id=i+1;
        p.needTime=p.serviceTime;
        processQueue.push(p);
    }
}

//系统开始调度
void beginDispatch()
{
    if (runQueue.empty())
    {
        if (!readyQueue.empty())
        {
            strcpy(readyQueue.front().state,"Run");
            runQueue.push(readyQueue.front());
            readyQueue.pop();
            runQueue.front().CPUTime++;
            runQueue.front().needTime--;
            time++;
        }
        else if(!blockQueue.empty())
        {
            char chance='p';
            cout<<endl;
            cout<<"********就绪队列不为空*********************"<<endl;
            cout<<"********若结束程序请按y,若不结束请按n******"<<endl;
            cin>>chance;
            if(chance=='y')
            {
                finish = true;
            return;
            }
        }
        else if(!hungQueue.empty())
        {
            char chance='p';
            cout<<endl;
            cout<<"********挂起队列不为空*********************"<<endl;
            cout<<"********若结束程序请按y,若不结束请按n******"<<endl;
            cin>>chance;
            if(chance=='y')
            {
                finish = true;
            return;
            }
        }
        else
        {
            finish = true;
            return;
        }
    }
    else if (!runQueue.empty())
    {
        if (runQueue.front().needTime == 0)
        {
            runQueue.front().finishTime = time;
            strcpy(runQueue.front().state,"Finish");
            finishQueue.push(runQueue.front());
            runQueue.pop();
            if (!readyQueue.empty())
            {
                strcpy(readyQueue.front().state,"Run");
                runQueue.push(readyQueue.front());
                readyQueue.pop();
            }
        }
        //先来先服务
        if (algorithm == 1)
        {
            time++;
            runQueue.front().CPUTime++;
            runQueue.front().needTime--;
        }
        //优先级
        if (algorithm == 2)
        {
            time++;
            runQueue.front().CPUTime++;
            runQueue.front().needTime--;
        }
        //时间片轮转算法
        if(algorithm == 3)
        {
            time++;
            runQueue.front().CPUTime++;
            runQueue.front().needTime--;
            if (runQueue.front().needTime != 0)
            {
                if ((runQueue.front().CPUTime >= timeslice) && (runQueue.front().CPUTime % timeslice == 0))
                {
                    strcpy(runQueue.front().state,"Ready");
                    readyQueue.push(runQueue.front());
                    runQueue.pop();
                    if (!readyQueue.empty())
                    {
                        strcpy(readyQueue.front().state,"Run");
                        runQueue.push(readyQueue.front());
                        readyQueue.pop();
                    }
                }
            }
        }
    }
}

//当前运行进程请求 I/O 事件
void IORequest()
{
    if (!runQueue.empty())
    {
        if (runQueue.front().needTime != 0)
        {
            strcpy(runQueue.front().blockCause, "请求 I/O 事件");
            strcpy(runQueue.front().state,"Wait");
            blockQueue.push(runQueue.front());
            runQueue.pop();
        }
    }
    else
    {
        cout << "当前无运行进程" << endl;
    }
}

//某进程I/O完成
void IOFinish()
{
    //空
    if (blockQueue.empty())
    {
        cout << "目前无阻塞进程" << endl;
    }
    //不空
    else
    {
        int id;
        cout << "请输入I/O完成的进程ID" << endl;
        cin >> id;
        for (int i = 0; i < blockQueue.size(); i++)
        {
            if (blockQueue.front().id == id)
            {
                strcpy(blockQueue.front().blockCause, " ");
                strcpy(blockQueue.front().state,"Ready");
                readyQueue.push(blockQueue.front());
                blockQueue.pop();
                if (algorithm == 1)//先来先服务
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp1());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
                if (algorithm == 2)//优先级
                { if (algorithm == 1)//先来先服务
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp1());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp2());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
                if (algorithm == 3)//时间片轮转
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
            }
            else
            {
                blockQueue.push(blockQueue.front());
                blockQueue.pop();
            }
        }
    }
}
//时间片到期
void timesliceDaoqi()
{
    if (!runQueue.empty())
    {
        if (runQueue.front().needTime != 0)
        {
            strcpy(runQueue.front().state,"Ready");
            readyQueue.push(runQueue.front());
            runQueue.pop();
        }
    }
    else
    {
        cout << "当前无运行进程" << endl;
    }
}
//其他阻塞事件
void ElseZC()
{
    if (!runQueue.empty())
    {
        if (runQueue.front().needTime != 0)
        {
            strcpy(runQueue.front().blockCause, "其他阻塞事件");
            strcpy(runQueue.front().state,"Wait");
            blockQueue.push(runQueue.front());
            runQueue.pop();
        }
    }
    else
    {
        cout << "当前无运行进程" << endl;
    }
}
void ElseZCFinish()
{
    //空
    if (blockQueue.empty())
    {
        cout << "目前无阻塞进程" << endl;
    }
    //不空
    else
    {
        int id;
        cout << "请输入其他阻塞事件完成的进程ID" << endl;
        cin >> id;
        for (int i = 0; i < blockQueue.size(); i++)
        {
            if (blockQueue.front().id == id)
            {
                strcpy(blockQueue.front().blockCause, " ");
                strcpy(blockQueue.front().state,"Ready");
                readyQueue.push(blockQueue.front());
                blockQueue.pop();
               if (algorithm == 1)//先来先服务
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp1());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
                if (algorithm == 2)//优先级
                { if (algorithm == 1)//先来先服务
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp1());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp2());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
                if (algorithm == 3)//时间片轮转
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
            }
            else
            {
                blockQueue.push(blockQueue.front());
                blockQueue.pop();
            }
        }
    }
}
//挂起
void Hung()
{
    if (!runQueue.empty())
    {
        if (runQueue.front().needTime != 0)
        {
            strcpy(runQueue.front().blockCause, "请求挂起");
            strcpy(runQueue.front().state,"Hung");
            hungQueue.push(runQueue.front());
            runQueue.pop();
        }
    }
    else
    {
        cout << "当前无运行进程" << endl;
    }
}
//某进程挂起完成
void HungFinish()
{
    //空
    if (hungQueue.empty())
    {
        cout << "目前无挂起进程" << endl;
    }
    //不空
    else
    {
        int id;
        cout << "请输入挂起完成的进程ID" << endl;
        cin >> id;
        for (int i = 0; i < hungQueue.size(); i++)
        {
            if (hungQueue.front().id == id)
            {
                strcpy(hungQueue.front().blockCause, " ");
                strcpy(hungQueue.front().state,"Ready");
                readyQueue.push(hungQueue.front());
                hungQueue.pop();
                if (algorithm == 1)//先来先服务
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp1());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
                if (algorithm == 2)//优先级
                { if (algorithm == 1)//先来先服务
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp1());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    sort(temp, temp + n, cmp2());
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
                if (algorithm == 3)//时间片轮转
                {
                    //排序
                    PCB temp[readyQueue.size()];
                    int n = 0;
                    while (!readyQueue.empty())
                    {
                        temp[n] = readyQueue.front();
                        readyQueue.pop();
                        n++;
                    }
                    for (int i = 0; i < n; i++)
                    {
                        readyQueue.push(temp[i]);
                    }
                }
            }
            else
            {
                hungQueue.push(hungQueue.front());
                hungQueue.pop();
            }
        }
    }
}


//显示就绪队列
void displayReady()
{
    cout << "----------------就绪队列----------------" << endl;
    queue<PCB> temp = readyQueue;
    while (!temp.empty())
    {
        if(algorithm == 1)
        {
            cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 2)
        {
            cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 3)
        {
            cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
    }

}
//显示运行队列
void displayRun()
{
    cout << "----------------运行队列----------------" << endl;
    queue<PCB> temp = runQueue;
   while (!temp.empty())
    {
        if(algorithm == 1)
        {
            cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 2)
        {
            cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 3)
        {
            cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
    }
}
//显示阻塞队列
void displayBlock()
{
    cout << "----------------阻塞队列----------------" << endl;
    queue<PCB> temp = blockQueue;
    while (!temp.empty())
    {
        if(algorithm == 1)
        {
            cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  阻塞原因"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 2)
        {
            cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  阻塞原因"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<"      "<<temp.front().blockCause<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 3)
        {
            cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  阻塞原因"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                temp.pop();
                cout << endl;
            }
        }
    }
}
//显示完成队列
void displayFinish()
{
    cout << "----------------完成队列----------------" << endl;
    queue<PCB> temp = finishQueue;
    while (!temp.empty())
    {
        if(algorithm == 1)
        {
            cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  完成时间"<< "  周转时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"         "<< temp.front().finishTime<<"         "<< temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 2)
        {
            cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  完成时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"         "<< temp.front().finishTime<<"           "<< temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 3)
        {
            cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  完成时间"<< "  状态"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"         "<< temp.front().finishTime<<"           "<<temp.front().state<<endl;
                temp.pop();
                cout << endl;
            }
        }
    }

}
//显示挂起队列
void displayHung()
{
    cout << "----------------挂起队列----------------" << endl;
    queue<PCB> temp = hungQueue;
    while (!temp.empty())
    {
        if(algorithm == 1)
        {
            cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  挂起原因"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 2)
        {
            cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  挂起原因"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<"      "<<temp.front().blockCause<<endl;
                temp.pop();
                cout << endl;
            }
        }
        if(algorithm == 3)
        {
            cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  挂起原因"<< endl;
            while (!temp.empty())
            {
                cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                temp.pop();
                cout << endl;
            }
        }
    }
}
//先来先服务
void FCFS()
{
    algorithm = 1;
    PCB temp[processQueue.size()];
    int n = 0;
    while (!processQueue.empty())
    {
        temp[n] = processQueue.front();
        processQueue.pop();
        n++;
    }
    sort(temp, temp + n, cmp1());
    for (int i = 0; i < n; i++)
    {
        strcpy(temp[i].state,"Ready");
        readyQueue.push(temp[i]);
    }
}
//优先级调度算法
void SJF()
{
    algorithm = 2;
    PCB temp[processQueue.size()];
    int n = 0;
    while (!processQueue.empty())
    {
        temp[n] = processQueue.front();
        processQueue.pop();
        n++;
    }
    sort(temp, temp + n, cmp2());
    for (int i = 0; i < n; i++)
    {
        strcpy(temp[i].state,"Ready");
        readyQueue.push(temp[i]);
    }
}
//时间片轮转
void RR()
{
    cout << "请输入时间片大小" << endl;
    cin >> timeslice;
    algorithm = 3;
    readyQueue = processQueue;
    for (int i = 0; i < readyQueue.size(); i++)
    {
        strcpy(readyQueue.front().state,"Ready");
        readyQueue.push(readyQueue.front());
        readyQueue.pop();
    }
}

int main()
{
    cout<<"********进程状态转换系统********"<<endl;
    int chance;
    cout << "1:自动添加进程    2:手动添加进程" << endl;
    cin>>chance;
    switch(chance)
    {
    case 1:
        Init();
        break;
    case 2:
        addProcess();
        break;
    }
    int e;
    cout << "请输入算法" << endl;
    cout << "1.先来先服务 2.优先级抢占 3.时间片轮转" << endl;
    cin >> e;
    switch (e)
    {
    case 1:
        FCFS();
        break;
    case 2:
        SJF();
        break;
    case 3:
        RR();
        break;
    }
    while (true)
    {
        int e;
        cout << "请输入操作" << endl;
        cout << "1.开始调度 2.IO请求 3.IO完成 4.时间片到期 5.其他阻塞事件 6.其他阻塞事件完成 7.挂起 8.挂起完成 0.退出" << endl;
        cin >> e;
        switch (e)
        {
        case 1:
            beginDispatch();
            break;
        case 2:
            IORequest();
            break;
        case 3:
            IOFinish();
            break;
        case 4:
            timesliceDaoqi();
            break;
        case 5:
            ElseZC();
            break;
       case 6:
            ElseZCFinish();
            break;
        case 7:
            Hung();
            break;
        case 8:
            HungFinish();
            break;
        case 0:
            exit(0);
        }
        displayReady();
        displayRun();
        displayBlock();
        displayFinish();
        displayHung();
        cout << "当前系统CPU时间：" << time << endl;
        if (finish)
        {
            cout << "当前进程全部完成" << endl;
            cout << "当前时间：" << time << endl;
            break;
        }
        system("pause");
    }
    system("pause");
    return 0;
}
小蒋的进阶之行
关注
  • 8
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
【操作系统】实验二 进程控制实验
AGATHA_66的博客
01-11 1934
本人一直想找时间系统整理一下之前做过的一些实验，便于后续用到的时候可以尽快的使用，po出来也便于大家交流学习，有问题欢迎交流指正，与诸君共勉！操作系统实验二，进程控制。
操作系统实验——基于Java的模拟操作系统进程切换（简易版）
榴莲男孩的博客
11-05 2862
实验任务 创建一个进程，给出工作量，每个进程所占的时间片大小为20个单位，实现就绪状态到执行状态之间的转化。如果一个进程在执行，点击其I/O请求即可产生阻塞，实现了等待一个事件的状态转移。阻塞状态到就绪状态需要事件发生，本程序为了简化，过40个时间单位自动解锁。本程序可以在VC、或其他程序设计语言中实现，容易使用时钟控件。在控制台模式下，该方式不是非常合适。 开始实验 一、 实验目的： 通过实验进一步了解进程状态之间的转换和进程控制等相关操作，通过实验的方法模拟进程在操作系统中是如何进行切换的，并掌握进程的
操作系统用C语言编写程序，模拟实现创建新的进程：查看运行进程；换出某个进程：杀死运行进程等功能。
热门推荐
Sum
06-03 1万+
进程管理实验目的实验内容实验步骤实验代码 实验目的 1．理解进程的概念，明确进程和程序的区别 2．理解并发执行的实质。 3．掌握进程的创建、睡民、撤销等进程控制方法。 实验内容 用C语言编写程序，模拟实现创建新的进程：查看运行进程；换出某个进程：杀死运行进程等功能。 实验步骤 进程 1．进程的含义 进程是程序在一个数据集合上的运行过程，是系统资源分配和调度的一个独立单位。一个程序在不同数据集合上运行，乃至一个程序在同样数据集合上的多次运行都是不同的进程。 2．进程的状态 通常，一个进程必须具有就绪、执行和阻
操作系统：进程状态转换模拟，C语言实现
weixin_45038876的博客
10-02 3779
编写并调试一个模拟的进程调度和进程状态转换过程，采用“基于时间片轮转法”调度算法对N（N不小于5）个进程进行调度。要求使用C/C++编程实现（如有难度也可酌情使用Java或C#实现）。首先绘制流程图，然后将程序源代码和运行效果放入实验报告中。 简单轮转法的基本思想是：所有就绪进程按先来先服务的方式排成一个队列，总是把处理机分配给队头的进程，各进程占用CPU的时间片长度相同（如1个CPU时间单位）。当把处理机分配给队头的进程后，该进程出就绪队列，并将进程状态从就绪态变化为运行态。如果运行进程用完它的时间片后还
进程的三种状态及转换
uyehniy的专栏
04-15 1691
1.进程的三种基本状态     进程在运行中不断地改变其运行状态。通常，一个运行进程必须具有以下三种基本状态。  就绪(Ready)状态     当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。  执行（Running）状态 当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。  阻塞(Bloc
操作系统实验 模拟 作业调度 模拟进程控制
11-02
利用简单的结构和控制方法模拟进程结构、进程状态和进程控制。 （二） 实验内容与步骤： 用PCB表示整个进程实体，利用随机数方法或键盘控制方法模拟进程执行中产生的事件。或者利用鼠标或者键盘中断的基于图形接口方式的进程控制管理。 具体过程： 1、 定义PCB（可以采用静态结构或动态结构）：包括理论PCB中的基本内容，如内部ID、外部ID、进程状态、队列指针。由于无法实现真正的进程创建功能，在实验中只需建立PCB，用它代表完整的进程。 2、 定义进程状态转换方式：进程的状态转换是由进程内部操作或操作系统的控制引起，由于无法实现这些功能，学生可以采用随机数方法或键盘控制方法模拟，并实现对应的控制程序。随机方法指产生1－6的随机数，分别代表创建进程(c)、结束进程(e)、进程阻塞(b)、激活进程(w)、调度进程(p)、时间片到(t)等事件；键盘模拟方法指定义6种按键代表以上6种事件。 3、 根据四种事件处理就绪队列、阻塞队列和当前执行中的进程。 4、 每次事件处理后应形象地显示出当前系统中的执行进程是哪一个，就绪队列和阻塞队列分别包含哪些进程。
操作系统实验一：进程调度
05-31
在计算机科学中，操作系统（Operating System, OS）是管理计算机硬件与软件资源的核心程序，它是计算机系统的关键组成部分。本实验主要关注的是操作系统中的一个核心概念——进程调度。进程调度是操作系统内核的重要...
操作系统对进程状态的转换
12-28
线程的状态转换（如新建、就绪、运行、等待、阻塞和结束）与操作系统进程状态转换有相似之处，但线程的管理更为灵活，因为线程之间的切换成本比进程低。 总结，操作系统对进程状态的转换是保证系统效率和并发性的...
操作系统实验：模拟最高优先数优先进程调度
12-14
1. **进程管理**：理解进程的生命周期，包括创建、执行、等待、就绪和终止等状态转换。掌握进程控制块（PCB）的概念，它是操作系统存储关于进程信息的数据结构。 2. **优先级调度**：了解如何为进程分配优先级，并...
操作系统实验1进程状态转换.doc
12-22
为了模拟进程状态转换，我们设计了一个程序来实现进程状态转换的过程。该程序使用 PCB 结构体来表示进程，并使用链表来实现进程队列的管理。 四、实验结果 通过本实验，我们可以看到进程状态转换的整个过程，从...
操作系统上机实验报告 进程状态转换及其PCB的变化
07-18
1．目的： 自行编制模拟程序，通过形象化的状态显示，深入理解进程的概念、进程之间的状态转换及其所带来的PCB内容 、组织的变化，理解进程与其PCB间的一一对应关系。 2. 内容及要求： 1) 设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。 2) 独立编写、调试程序。进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。 3) 合理设计与进程PCB相对应的数据结构。PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。 4) 设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。 5) 代码书写要规范，要适当地加入注释。 6） 认真进行预习，完成预习报告。 7） 实验完成后，要认真总结，完成实验报告。 3．使用的数据结构及说明： 在本实验中，主要用到的数据结构是PCB的结构，其中PCB的数据结构如下： struct PCB { int P_Id; //PCB的ID号 char P_Name[10]; //PCB的名称 char P_State[10]; //PCB状态 int P_Runtime; //PCB的所需要的运行时间 int P_Requiry; //PCB所需要的资源要求 struct PCB * next ; //PCB块的下一个指针 } ; 其中，P_Id,和P_Name用来标示一个进程，而P_State用来标示进程的五种状态：Create_state,Ready_state,Block_state,Run_state,Exit_state。P_Runtime标示要完成一个进程所需要的时间。P_Requiry标示一个进程的执行所需要的其他条件，当其他的条件满足，则P_Requiry置1，否则置0。Struct PCB * next 用来指向同一队列中的下一个PCB块。
操作系统实验一（进程调度）
03-23
操作系统是计算机系统的核心组成部分，它负责管理系统的硬件资源和软件资源，协调计算机的运行，为用户提供服务。在操作系统中，进程调度是一项至关重要的任务，它决定了哪些进程可以在CPU上执行，以及它们如何共享...
操作系统 进程的状态和转换 进程控制 进程通信
weixin_47433238的博客
09-28 621
添加链接描述 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、进程概念1.1 定义1.2 组成1.2.1 PCB1.2.2 程序段，数据段1.3 组织方式1.3.1 链接方式1.3.2 索引方式1.3 特征拓展2.1 进程的状态和转换2.1.1基本状态（三种）创建态，就绪态运行态2.1.2另两种阻塞态终止态2.1.3进程状态的转变2.2 进程控制2.2.1 定义二、二主题1.定义总结 前言 提示：这里可以添加本文要记录的大概内容： 提示：以下是本篇文章正文内容，下
操作系统进程状态和状态转换详解
|~~~热爱生活、努力学习的小伙汁~~~|
07-16 2907
之前的有博文对进程和线程的区别进行了详细的介绍，并且引入进程的目的是为了能够使程序并发的执行，并且可以对并发执行的程序加以描述和控制。 这篇博文，我们就来对进程的状态转换来进行详细的分析下。 注意：本博文中进程均是在传统操作系统中的进程，即 OS是进行资源分配的基本单位，也是OS 进行调度的一个独立单位。 在开始之前，我们对进程和程序来进行一个对比： 程序是静态的，而进程是动态的。 程序可以作为一种软件资源长期存在，而进程是有一定生命周期的。程序是永久的，进程是暂时的。 进程更能真实地描述并发，而程序不能
Linux CPU性能 系统当中的不可中断进程D和僵尸进程Z
小楼一夜听春雨，深巷明朝卖杏花
07-15 935
CPU使用率的类型。除了用户CPU之外，它还包括系统 CPU （比如上下文切换）、等待I/O的CPU （比如等待磁盘的响应）以及中断CPU （包括软中断和硬中断）等。 上下文切换会导致系统CPU使用率高，剩下的等待I/O的 CPU使用率（以下简称为iowait）升高，也是最常见的一个服务器性能问题。 进程状态 当iowait升高时，进程很可能因为得不到硬件的响应，而长时间处于不可中断状态。从ps或者top命令的输出中，你可以发现它们都处于D状态，也就是不可中断状态（Uninterrup...
操作系统实验
A_jingluo的博客
05-09 1114
实验一 进程状态转换模拟 实验二 生产者消费者问题模拟 实验三 进程的管道通信 实验四 页面置换算法
【002 操作系统】进程的状态及状态转换图？
kashine的博客
07-30 5289
NULL -> 创建状态：一个新进程被创建时的第一个状态；创建状态 -> 就绪状态：当进程被创建完成并初始化后，一切就绪准备运行时，变为就绪状态，这个过程是很快的；就绪态 -> 运行状态：处于就绪状态的进程被操作系统的进程调度器选中后，就分配给 CPU 正式运行该进程；运行状态 -> 结束状态：当进程已经运行完成或出错时，会被操作系统作结束状态处理；运行状态 -> 就绪状态。
操作系统//进程状态转换模拟（STLqueue、时间片轮转）
ChenChenYang_int的博客
06-01 388
用STLqueue实现三状态图转换
go--本地下载包
最新发布
weixin_63566388的博客
07-23 443
下载完成后，你可以验证包是否已正确下载。下载并安装适合你操作系统的版本。：确保已经安装 Go。
安徽工业大学操作系统实验指南：进程管理与存储设备
- 实验目标：理解进程管理的基本原理，包括进程状态转换和通信机制。 - 实验内容和步骤：可能会涉及到进程创建、同步与通信技术的实践。 **实验三：进程同步的经典算法** - 背景知识：进程同步是为了协调多个进程...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值