注：以下代码为实验一和实验二的结合体，即为实验二的最后结果

实验一

实验目的

多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。本实验模拟实现处理机调度，加深了解处理机调度的工作过程。

实验内容

选择一个调度算法，实现处理机调度。

1）设计一个按优先权调度算法实现处理机调度的程序；

2）设计按时间片轮转实现处理机调度的程序。

实验方法

1）构建进程PCB，PCB内容包括：进程名/PID；要求运行时间（单位时间）；优先权；状态：PCB指针；

2）设置后备队列和挂起队列，设计作业调度算法、进程调度算法，以及挂起、解挂功能；

3）采用图形界面，动态展示调度过程中各进程及队列变化。

实验步骤

需求分析

①　可以手动增加进程，并按优先级排序；

②　采用动态优先权调度，从就绪队列选进程运行，运行一个时间单位后，优先权减1，运行时间减1，运行时间为0时，撤销该进程；

③　采用图形界面，动态展示调度过程中各进程及队列变化；

⑤　规定一定道数，同时设置后备和挂起；

⑥　如果内存中进程少于规定道数，可自动从后备队列通过作业调度选择一作业进入，作业调度算法可自行选择；

⑦　选择被挂起的进程，进入挂起队列，并设置解挂的功能用于将被挂起的进程解挂加入就绪队列；

概要设计

① 设计图形化界面，整体分为五大区域：后备队列、就绪队列、挂起队列、运行区域、增加进程的区域；

② 增加进程区域：通过20个类比现实应用的按钮，实现动态增加进程；

③ 当增加的进程数<道数，则直接进入就绪队列，否则进入后备队列进行等待；

④ 在就绪队列中可以选择进程挂起，被挂起的进程数与就绪队列中的进程数之和不得大于道数；

⑤ 为实现优先级调度，对进入各个队列的进程按照优先级进行排序，优先级高者先进入CPU运行；

⑥ 每运行一次，该进程的优先级减一，运行时间减一，当运行时间为0时，进程结束。当运行时间不为0时，重新根据当前状态加入队列之中

⑦ 各种功能的实现主要通过按钮的点击，每一个进程增加按钮，实现动态添加，挂起和解挂均通过按钮实现。运行与结束也是通过按钮实现。

⑧ 后备队列、就绪队列、挂起队列通过表格来呈现，通过List来实现

详细设计

① 设计PCB，包含进程名，进程优先级，运行时间，当前状态（分为四个状态：后备、等待、运行、结束）

② 设计界面，初始化界面状态，共有7个Label，4个控制按钮，20个增加进程的按钮，3个显示当前运行内容的textField

③ 初始化表格initTable()，再每次更新时，方便重写

④ 初始化20个进程，initPCB();

⑤ 三个更新表格的函数，通过重写，实时展示结果updateReadyTable(); updateWaitTable();
updateGuaqiTabel();

⑥ 设置判断该进程进入哪一个队列的函数，enter(PCB p);

⑦ 对于已经加入的进程，根据优先级排序的函数QList
listSort(QList l);

⑧ 对于每一个按钮设置槽函数，20个进程的槽函数基本一致。点击运行时，就绪队列，后续队列均会发生改变，点击结束运行，则所有进程结束

⑨ 当选中一个想要挂起的队列时，点击挂起即可，解挂亦是。

⑩ 界面美化设计，同时兼顾用户友好交互，设置大量提示语句

运行结果

基础界面

增加进程

成功加入进程，道数为6，先增加的六个进入就绪队列，后增加的三个进入后备队列

此时已经将QQ挂起，选择PPT和点击挂起后，可以将PPT也挂起

运行过程，挂起队列不参与运行

wechat运行时间减至0，该进程结束

实验二

实验目的

帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收

实验内容

在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收

实验方法

1、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表；

表目内容：起址、长度、状态（未分/空表目）

2、结合实验一，PCB增加为：

{PID，要求运行时间，优先权，状态，所需主存大小，主存起始位置，PCB指针}

3、采用最先适应算法分配主存空间；

4、进程完成后，回收主存，并与相邻空闲分区合并。

实验步骤

需求分析

① 提供固定大小的主存空间

② 当进程进入作业队列时，首先判断内存是否足够使其进入

③ 使用连续分配中的可变分区分配每一个进程的内存

④ 操作系统本身占据一定的内存

⑤ 采用最先适应算法，即从0开始查找，只要存在可以进入的空间，就存入此段内存

⑥ 在实验一的基础上采用图形化界面表示

⑦ 当进程运行结束后，回收主存，并与相邻的空闲分区合并

概要设计

① 通过一个固定长度的表格表示内存空间，并表明使用该段内存的进程的名称，长度，起址等

② 通过在表格上是否呈现来模拟进程是否进入内存

③ 点击运行之后，根据动态优先级调度进行运行，当运行结束时，释放其占用的内存，将表格中数据清空模拟空间的释放

④ 当进程结束后，相邻空间自动合并

⑤ 更新图形化界面，增加主存管理的显示部分

详细设计

① 在实验一的基础上，PCB增加主存起始地址和占用主存大小两项内容。

② 在初始化PCB中，增加初始化每一个进程的主存大小，主存起始地址无需初始化

③ 增加判断进程当前能否进入的函数isOk(PCB p);

③ 在增加进程的槽函数中，增加判断条件通过判断能否进入而产生不同的效果

④ 增加一个标签和表格用于在图形化界面中表现主存管理

⑤ 在初始化表格中增加对于新表格的初始化，同时新表格中的状态栏全部初始化为0，前10个空间初始化给操作系统本身

⑥ 增加更新主存管理表格的函数updateMemoryTable();

运行结果

基础界面

增加一个进程后，主存发生变化

当一个进程结束后，其主存空间释放

新增加的进程会根据大小判断存入的位置和能否存入

当加入的进程主存空间不够时，不予加入，并给客户以提示

实验代码

pcb.h

#ifndef PCB_H
#define PCB_H
#include <QString>


class PCB
{
    
public:
    PCB();
    QString getName() const;
    void setName(const QString &value);


    int getPriority() const;
    void setPriority(int value);


    int getTime() const;
    void setTime(int value);


    int getStatus() const;
    void setStatus(int value);


    int getMemorySize() const;
    void setMemorySize(int value);


    int getMemorylocation() const;
    void setMemorylocation(int value);


private:
    QString name;//名称
    int priority;//优先级
    int time;//运行时间
    int status;//1表示后备，2表示等待，3表示运行，4表示结束
    int memorySize;//主存大小
    int memorylocation;//主存起始地址
};


#endif // PCB_H

widget.h

#ifndef WIDGET_H
#define WIDGET_H


#include <QWidget>
#include <QGridLayout>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QStandardItem>
#include <QStandardItemModel>
#include <QTreeView>
#include <QTableView>
#include <QHeaderView>
#include <QLabel>
#include <QFormLayout>
#include <QLineEdit>
#include <QString>
#include <QIcon>
#include <QMessageBox>
#include <QList>
#include <QModelIndex>
#include <QTimer>
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QHeaderView>
#include "pcb.h"
/*********QPushButton参数********/
const QString button_style="QPushButton{background-color:rgb(255,255,255);border-radius:10px;font-size:30px;color:rgb(105,105,105);}"
                                     "QPushButton:hover{background-color:rgb(105,105,105);border-radius:10px;font-size:30px; color:rgb(255,255,255);}"
                                    "QPushButton:pressed{background-color:black;border-radius:10px;font-size:30px; }";
const QString label_style="QLabel{background-color:rgb(79,79,79);border:0px groove gray;border-radius:10px;padding:2px 4px;font-size:40px;color:rgb(255,255,255)}";
const QString label_style2="QLabel{background-color:rgb(255,255,255);border:0px groove gray;border-radius:10px;padding:2px 4px;font-size:30px;color:black}";


class Widget : public QWidget
{
    
    Q_OBJECT


public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();


    void CreateView();//图形化界面
    void initTable();//初始化表格
    void updateReadyTable();//更新就绪表格
    void updateWaitTable();//更新后备表格
    void updateGuaqiTable();//更新挂起表格
    void updateMemoryTable();//更新主存管理表格
    void enter(PCB p);//加入进程
    void initPCB();//初始化20个PCB
    void refreshBtn();//重现button


    QList<PCB> listSort(QList<PCB> l);//按照优先级排序
    PCB returnPCB(QString name);//根据PCB名称返回PCB
    int getReadyIndex(PCB p);//获取就绪队列的index
    int getGuaqiIndex(PCB p);//获取挂起队列的index
    int isOk(PCB p);//判断能否进入内存
public slots:


    //进程调度
    void clickGuaqi();
    void clickJiegua();
    void clickRun();
    void clickFinish();


    //增加进程（20个）
    void clickAccess();
    void clickAmazon();
    void clickAndroid();
    void clickBaidumap();
    void clickBeing();
    void clickC();
    void clickChrome();
    void clickCloud();
    void clickExcel();
    void clickFirefox();
    void clickJava();
    void clickOffice();
    void clickOnenote();
    void clickPPT();
    void clickPython();
    void clickQQ();
    void clickQt();
    void clickSafari();
    void clickWechat();
    void clickWord();


private:


    QString finishName;
    //队列
    QList<PCB> wait;//后备队列
    QList<PCB> ready;//就绪
    QList<PCB> guaqi;//挂起


    //总道数
    int ways = 6;
    int MEMORY = 200;
    int OS_SIZE = 10;


    //定义20个进程
    PCB accessPCB;
    PCB amazonPCB;
    PCB androidPCB;
    PCB baidumapPCB;
    PCB beingPCB;
    PCB cPCB;
    PCB chromePCB;
    PCB cloudPCB;
    PCB excelPCB;
    PCB firefoxPCB;
    PCB javaPCB;
    PCB officePCB;
    PCB onenotePCB;
    PCB pptPCB;
    PCB pythonPCB;
    PCB qqPCB;
    PCB qtPCB;
    PCB safariPCB;
    PCB wechatPCB;
    PCB wordPCB;


    //六个状态标签
    QLabel* waitLabel;
    QLabel* readyLabel;
    QLabel* runningLabel;
    QLabel* guaqiLabel;
    QLabel* addLabel;
    QLabel* memoryLabel;


    //表示运行状态的标签
    QLabel* nameLabel;
    QLabel* priorityLabel;
    QLabel* timeLabel;


    //运行类按钮
    QPushButton* guaqiButton;
    QPushButton* jieguaButton;
    QPushButton* runButton;
    QPushButton* finishButton;


    //增加区按钮
    QPushButton* accessBtn;
    QPushButton* amazonBtn;
    QPushButton* androidBtn;
    QPushButton* baidumapBtn;
    QPushButton* beingBtn;
    QPushButton* cBtn;
    QPushButton* chromeBtn;
    QPushButton* cloudBtn;
    QPushButton* excelBtn;
    QPushButton* firefoxBtn;
    QPushButton* javaBtn;
    QPushButton* officeBtn;
    QPushButton* onenoteBtn;
    QPushButton* pptBtn;
    QPushButton* pythonBtn;
    QPushButton* qqBtn;
    QPushButton* qtBtn;
    QPushButton* safariBtn;
    QPushButton* wechatBtn;
    QPushButton* wordBtn;


    //进程类按钮
    //运行部分显示数据设计
    QLineEdit* nameEdit;
    QLineEdit* priorityEdit;
    QLineEdit* timeEdit;


    //运行区布局
    QFormLayout* formLayout;
    QVBoxLayout* vLayout;
    QHBoxLayout* buttonLayout;


    //表格部分布局
    QGridLayout* gridTotalLayout;


    //增加区布局
    QVBoxLayout* addVLayout;
    QGridLayout* addGridLayout;


    //整体布局
    QGridLayout *mainLayout;


    QStandardItemModel *standItemModel;
    QStandardItemModel *standItemModel2;
    QStandardItemModel *standItemModel3;
    QStandardItemModel *standItemModel4;


    QTableView *tableView;
    QTableView *tableView2;
    QTableView *tableView3;
    QTableView *tableView4;
};


#endif // WIDGET_H

pcb.cpp

#include "pcb.h"


PCB::PCB()
{
    


}

//基础的get,set方法
QString PCB::getName() const
{
    
    return name;
}


void PCB::setName(const QString &value)
{
    
    name = value;
}


int PCB::getPriority() const
{
    
    return priority;
}


void PCB::setPriority(int value)
{
    
    priority = value;
}


int PCB::getTime() const
{
    
    return time;
}


void PCB::setTime(int value)
{
    
    time = value;
}


int PCB::getStatus() const
{
    
    return status;
}


void PCB::setStatus(int value)
{
    
    status = value;
}


int PCB::getMemorySize() const
{
    
    return memorySize;
}


void PCB::setMemorySize(int value)
{
    
    memorySize = value;
}


int PCB::getMemorylocation() const
{
    
    return memorylocation;
}


void PCB::setMemorylocation(int value)
{
    
    memorylocation = value;
}

widget.cpp

#include "widget.h"
#include <QDebug>


Widget::Widget(QWidget *parent) :
    QWidget(parent)
{
    
    initPCB();
    CreateView();
    initTable();
}


Widget::~Widget()
{
    


}
void Widget::CreateView()
{
    
    //表格
    //后备队列的表格
    //添加QTableView代码
    tableView = new QTableView;
    standItemModel = new QStandardItemModel();


    //就绪队列的表格
    //添加QTableView代码
    tableView2 = new QTableView;
    standItemModel2 = new QStandardItemModel();


    //挂起队列的表格
    //添加QTableView代码
    tableView3 = new QTableView;
    standItemModel3 = new QStandardItemModel();


    //分区
    tableView4 = new QTableView;
    standItemModel4 = new QStandardItemModel();


    //主布局
    mainLayout = new QGridLayout;       //垂直布局
    mainLayout->setSpacing(10);
    mainLayout->setMargin(10);


    //运行区布局
    formLayout  = new QFormLayout;
    formLayout->setSpacing(10);
    formLayout->setMargin(10);


    vLayout = new QVBoxLayout;
    buttonLayout = new QHBoxLayout;


    //增加区布局
    addVLayout = new QVBoxLayout;
    addGridLayout = new QGridLayout;
    addGridLayout->setSpacing(10);
    addGridLayout->setMargin(10);


    //其他布局
    gridTotalLayout = new QGridLayout;
    gridTotalLayout->setSpacing(10);
    gridTotalLayout->setMargin(10);


    //初始化五个标签
    waitLabel = new QLabel("后备队列");
    waitLabel->setStyleSheet(label_style);


    readyLabel = new QLabel("就绪队列");
    readyLabel->setStyleSheet(label_style);


    guaqiLabel = new QLabel("挂起队列");
    guaqiLabel->setStyleSheet(label_style);


    memoryLabel = new QLabel("主存管理");
    memoryLabel->setStyleSheet(label_style);


    addLabel = new QLabel("增加进程");
    addLabel->setStyleSheet(label_style);
    addLabel->setHidden(true);


    runningLabel = new QLabel("运行队列");
    runningLabel->setStyleSheet(label_style);


    waitLabel->setAlignment(Qt::AlignCenter);
    readyLabel->setAlignment(Qt::AlignCenter);
    runningLabel->setAlignment(Qt::AlignCenter);
    guaqiLabel->setAlignment(Qt::AlignCenter);
    addLabel->setAlignment(Qt::AlignCenter);
    memoryLabel->setAlignment(Qt::AlignCenter);


    //初始化四个按钮
    guaqiButton = new QPushButton("挂起进程");
    guaqiButton->setStyleSheet(button_style);
    jieguaButton = new QPushButton("解挂进程");
    jieguaButton->setStyleSheet(button_style);
    runButton = new QPushButton("开始运行");
    runButton->setStyleSheet(button_style);
    finishButton = new QPushButton("结束运行");
    finishButton->setStyleSheet(button_style);


    //初始化运行界面
    nameLabel = new QLabel("进程名");
    priorityLabel = new QLabel("优先权");
    timeLabel = new QLabel("运行时间");


    nameLabel->setAlignment(Qt::AlignLeft);
    priorityLabel->setAlignment(Qt::AlignLeft);
    timeLabel->setAlignment(Qt::AlignLeft);


    nameLabel->setStyleSheet(label_style2);
    priorityLabel->setStyleSheet(label_style2);
    timeLabel->setStyleSheet(label_style2);


    nameEdit = new QLineEdit;
    nameEdit->setReadOnly(true);
    nameEdit->setStyleSheet("border-width:2px;border-color:black;border-radius:10px;font-size:30px;border-style:groove");
    nameEdit->setGeometry(400,925,190,70);
    priorityEdit = new QLineEdit;
    priorityEdit->setReadOnly(true);
    priorityEdit->setStyleSheet("border-width:2px;border-color:black;border-radius:10px;font-size:30px;border-style:groove");
    priorityEdit->setGeometry(400,1025,190,70);
    timeEdit = new QLineEdit;
    timeEdit->setReadOnly(true);
    timeEdit->setStyleSheet("border-width:2px;border-color:black;border-radius:10px;font-size:30px;border-style:groove");
    timeEdit->setGeometry(400,1105,190,70);


    //初始化20个进程按钮
    accessBtn = new QPushButton();
    accessBtn->setFixedSize(96,96);
    accessBtn->setStyleSheet(tr("background-image: url(:/image/images/Access.png);"));
    accessBtn->setFlat(true);
    connect(accessBtn,SIGNAL(clicked(bool)),this,SLOT(clickAccess()));


    amazonBtn = new QPushButton();
    amazonBtn->setFixedSize(96,96);
    amazonBtn->setStyleSheet(tr("background-image: url(:/image/images/Amazon.png);"));
    amazonBtn->setFlat(true);
    connect(amazonBtn,SIGNAL(clicked(bool)),this,SLOT(clickAmazon()));


    androidBtn = new QPushButton();
    androidBtn->setFixedSize(96,96);
    androidBtn->setStyleSheet(tr("background-image: url(:/image/images/Android.png);"));
    androidBtn->setFlat(true);
    connect(androidBtn,SIGNAL(clicked(bool)),this,SLOT(clickAndroid()));


    baidumapBtn = new QPushButton();
    baidumapBtn->setFixedSize(96,96);
    baidumapBtn->setStyleSheet(tr("background-image: url(:/image/images/baidumap.png);"));
    baidumapBtn->setFlat(true);
    connect(baidumapBtn,SIGNAL(clicked(bool)),this,SLOT(clickBaidumap()));


    beingBtn = new QPushButton();
    beingBtn->setFixedSize(96,96);
    beingBtn->setStyleSheet(tr("background-image: url(:/image/images/Being.png);"));
    beingBtn->setFlat(true);
    connect(beingBtn,SIGNAL(clicked(bool)),this,SLOT(clickBeing()));


    cBtn = new QPushButton();
    cBtn->setFixedSize(96,96);
    cBtn->setStyleSheet(tr("background-image: url(:/image/images/c.png);"));
    cBtn->setFlat(true);
    connect(cBtn,SIGNAL(clicked(bool)),this,SLOT(clickC()));


    chromeBtn = new QPushButton();
    chromeBtn->setFixedSize(96,96);
    chromeBtn->setStyleSheet(tr("background-image: url(:/image/images/chrome.png);"));
    chromeBtn->setFlat(true);
    connect(chromeBtn,SIGNAL(clicked(bool)),this,SLOT(clickChrome()));


    cloudBtn = new QPushButton();
    cloudBtn->setFixedSize(96,96);
    cloudBtn->setStyleSheet(tr("background-image: url(:/image/images/Cloud.png);"));
    cloudBtn->setFlat(true);
    connect(cloudBtn,SIGNAL(clicked(bool)),this,SLOT(clickCloud()));


    excelBtn = new QPushButton();
    excelBtn->setFixedSize(96,96);
    excelBtn->setStyleSheet(tr("background-image: url(:/image/images/Excel.png);"));
    excelBtn->setFlat(true);
    connect(excelBtn,SIGNAL(clicked(bool)),this,SLOT(clickExcel()));


    firefoxBtn = new QPushButton();
    firefoxBtn->setFixedSize(96,96);
    firefoxBtn->setStyleSheet(tr("background-image: url(:/image/images/firefox.png);"));
    firefoxBtn->setFlat(true);
    connect(firefoxBtn,SIGNAL(clicked(bool)),this,SLOT(clickFirefox()));


    javaBtn = new QPushButton();
    javaBtn->setFixedSize(96,96);
    javaBtn->setStyleSheet(tr("background-image: url(:/image/images/java.png);"));
    javaBtn->setFlat(true);
    connect(javaBtn,SIGNAL(clicked(bool)),this,SLOT(clickJava()));


    officeBtn = new QPushButton();
    officeBtn->setFixedSize(96,96);
    officeBtn->setStyleSheet(tr("background-image: url(:/image/images/Office.png);"));
    officeBtn->setFlat(true);
    connect(officeBtn,SIGNAL(clicked(bool)),this,SLOT(clickOffice()));


    onenoteBtn = new QPushButton();
    onenoteBtn->setFixedSize(96,96);
    onenoteBtn->setStyleSheet(tr("background-image: url(:/image/images/OneNote.png);"));
    onenoteBtn->setFlat(true);
    connect(onenoteBtn,SIGNAL(clicked(bool)),this,SLOT(clickOnenote()));


    pptBtn = new QPushButton();
    pptBtn->setFixedSize(96,96);
    pptBtn->setStyleSheet(tr("background-image: url(:/image/images/PPT.png);"));
    pptBtn->setFlat(true);
    connect(pptBtn,SIGNAL(clicked(bool)),this,SLOT(clickPPT()));


    pythonBtn = new QPushButton();
    pythonBtn->setFixedSize(96,96);
    pythonBtn->setStyleSheet(tr("background-image: url(:/image/images/python.png);"));
    pythonBtn->setFlat(true);
    connect(pythonBtn,SIGNAL(clicked(bool)),this,SLOT(clickPython()));


    qqBtn = new QPushButton();
    qqBtn->setFixedSize(96,96);
    qqBtn->setStyleSheet(tr("background-image: url(:/image/images/qq.png);"));
    qqBtn->setFlat(true);
    connect(qqBtn,SIGNAL(clicked(bool)),this,SLOT(clickQQ()));


    qtBtn = new QPushButton();
    qtBtn->setFixedSize(96,96);
    qtBtn->setStyleSheet(tr("background-image: url(:/image/images/qt.png);"));
    qtBtn->setFlat(true);
    connect(qtBtn,SIGNAL(clicked(bool)),this,SLOT(clickQt()));


    safariBtn = new QPushButton();
    safariBtn->setFixedSize(96,96);
    safariBtn->setStyleSheet(tr("background-image: url(:/image/images/safari.png);"));
    safariBtn->setFlat(true);
    connect(safariBtn,SIGNAL(clicked(bool)),this,SLOT(clickSafari()));


    wechatBtn = new QPushButton();
    wechatBtn->setFixedSize(96,96);
    wechatBtn->setStyleSheet(tr("background-image: url(:/image/images/wechat.png);"));
    wechatBtn->setFlat(true);
    connect(wechatBtn,SIGNAL(clicked(bool)),this,SLOT(clickWechat()));


    wordBtn = new QPushButton();
    wordBtn->setFixedSize(96,96);
    wordBtn->setStyleSheet(tr("background-image: url(:/image/images/Word.png);"));
    wordBtn->setFlat(true);
    connect(wordBtn,SIGNAL(clicked(bool)),this,SLOT(clickWord()));




    //建立信号与槽
    connect(guaqiButton,SIGNAL(clicked(bool)),this,SLOT(clickGuaqi()));
    connect(jieguaButton,SIGNAL(clicked(bool)),this,SLOT(clickJiegua()));
    connect(runButton,SIGNAL(clicked(bool)),this,SLOT(clickRun()));
    connect(finishButton,SIGNAL(clicked(bool)),this,SLOT(clickFinish()));


    //布局
    //运行区
    formLayout->addRow(nameLabel,nameEdit);
    formLayout->addRow(priorityLabel,priorityEdit);
    formLayout->addRow(timeLabel,timeEdit);
    buttonLayout->addWidget(runButton);
    buttonLayout->addWidget(finishButton);
    vLayout->addWidget(runningLabel);
    vLayout->addLayout(formLayout);
    vLayout->addLayout(buttonLayout);


    //其他(后备、就绪、挂起)
    gridTotalLayout->addWidget(waitLabel,0,0);
    gridTotalLayout->addWidget(tableView,1,0);


    gridTotalLayout->addWidget(readyLabel,0,1);
    gridTotalLayout->addWidget(tableView2,1,1);
    gridTotalLayout->addWidget(guaqiButton,2,1);


    gridTotalLayout->addWidget(guaqiLabel,0,2);
    gridTotalLayout->addWidget(tableView3,1,2);
    gridTotalLayout->addWidget(jieguaButton,2,2);


    gridTotalLayout->addWidget(memoryLabel,0,3,1,2);
    gridTotalLayout->addWidget(tableView4,1,3,1,2);


    //增加区
    addGridLayout->addWidget(accessBtn,0,0);
    addGridLayout->addWidget(amazonBtn,0,1);
    addGridLayout->addWidget(androidBtn,0,2);
    addGridLayout->addWidget(baidumapBtn,0,3);


    addGridLayout->addWidget(beingBtn,1,0);
    addGridLayout->addWidget(cBtn,1,1);
    addGridLayout->addWidget(chromeBtn,1,2);
    addGridLayout->addWidget(cloudBtn,1,3);


    addGridLayout->addWidget(excelBtn,2,0);
    addGridLayout->addWidget(firefoxBtn,2,1);
    addGridLayout->addWidget(javaBtn,2,2);
    addGridLayout->addWidget(officeBtn,2,3);


    addGridLayout->addWidget(onenoteBtn,3,0);
    addGridLayout->addWidget(pptBtn,3,1);
    addGridLayout->addWidget(pythonBtn,3,2);
    addGridLayout->addWidget(qqBtn,3,3);


    addGridLayout->addWidget(qtBtn,4,0);
    addGridLayout->addWidget(safariBtn,4,1);
    addGridLayout->addWidget(wechatBtn,4,2);
    addGridLayout->addWidget(wordBtn,4,3);


    addVLayout->addWidget(addLabel);
    addVLayout->addLayout(addGridLayout);


    //整体布局
    mainLayout->addLayout(gridTotalLayout,0,0,2,2);
    mainLayout->addLayout(vLayout,0,2);
    mainLayout->addLayout(addVLayout,1,2);


     //显示布局
    this->setLayout(mainLayout);
}
void Widget::initTable()
{
    
    //后备队列
    //添加表头
    standItemModel->setColumnCount(3);
    standItemModel->setHeaderData(0,Qt::Horizontal,QStringLiteral("进程名"));   //设置表头内容
    standItemModel->setHeaderData(1,Qt::Horizontal,QStringLiteral("优先级"));
    standItemModel->setHeaderData(2,Qt::Horizontal,QStringLiteral("运行时间"));


    //挂载表格模型
    tableView->setModel(standItemModel);


    //设置表格属性
    tableView->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);        //表头信息显示居中
    tableView->horizontalHeader()->setSectionResizeMode(0,QHeaderView::Fixed);  //设定表头列宽不可变
    tableView->horizontalHeader()->setSectionResizeMode(1,QHeaderView::Fixed);
    tableView->horizontalHeader()->setSectionResizeMode(2,QHeaderView::Stretch);//设定第2列表头弹性拉伸
    tableView->setColumnWidth(0,80);       //设定表格第0列宽度
    tableView->setColumnWidth(1,80);
    tableView->setColumnWidth(2,100);
    tableView->horizontalHeader()->setStyleSheet("QHeaderView::section{background:rgb(190,190,190);}");
    //设置相邻行颜色交替显示
    tableView->setAlternatingRowColors(true);
    tableView->verticalHeader()->hide();    //隐藏默认显示的行头
    tableView->setSelectionBehavior(QAbstractItemView::SelectRows); //设置选中时整行选中
    tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);  //设置表格属性只读，不能编辑


    //就绪队列
    //添加表头
    standItemModel2->setColumnCount(3);
    standItemModel2->setHeaderData(0,Qt::Horizontal,QStringLiteral("进程名"));   //设置表头内容
    standItemModel2->setHeaderData(1,Qt::Horizontal,QStringLiteral("优先级"));
    standItemModel2->setHeaderData(2,Qt::Horizontal,QStringLiteral("运行时间"));


    //挂载表格模型
    tableView2->setModel(standItemModel2);


    //设置表格属性
    tableView2->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);        //表头信息显示居中
    tableView2->horizontalHeader()->setSectionResizeMode(0,QHeaderView::Fixed);  //设定表头列宽不可变
    tableView2->horizontalHeader()->setSectionResizeMode(1,QHeaderView::Fixed);
    tableView2->horizontalHeader()->setSectionResizeMode(2,QHeaderView::Stretch);//设定第2列表头弹性拉伸
    tableView2->setColumnWidth(0,80);       //设定表格第0列宽度
    tableView2->setColumnWidth(1,80);
    tableView2->setColumnWidth(2,100);
    tableView2->horizontalHeader()->setStyleSheet("QHeaderView::section{background:rgb(190,190,190);}");
    //设置相邻行颜色交替显示
    tableView2->setAlternatingRowColors(true);
    tableView2->verticalHeader()->hide();    //隐藏默认显示的行头
    tableView2->setSelectionBehavior(QAbstractItemView::SelectRows); //设置选中时整行选中
    tableView2->setEditTriggers(QAbstractItemView::NoEditTriggers);  //设置表格属性只读，不能编辑


    //挂起队列
    //添加表头
    standItemModel3->setColumnCount(3);
    standItemModel3->setHeaderData(0,Qt::Horizontal,QStringLiteral("进程名"));   //设置表头内容
    standItemModel3->setHeaderData(1,Qt::Horizontal,QStringLiteral("优先级"));
    standItemModel3->setHeaderData(2,Qt::Horizontal,QStringLiteral("运行时间"));


    //挂载表格模型
    tableView3->setModel(standItemModel3);


    //设置表格属性
    tableView3->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);        //表头信息显示居中
    tableView3->horizontalHeader()->setSectionResizeMode(0,QHeaderView::Fixed);  //设定表头列宽不可变
    tableView3->horizontalHeader()->setSectionResizeMode(1,QHeaderView::Fixed);
    tableView3->horizontalHeader()->setSectionResizeMode(2,QHeaderView::Stretch);//设定第2列表头弹性拉伸
    tableView3->setColumnWidth(0,80);       //设定表格第0列宽度
    tableView3->setColumnWidth(1,80);
    tableView3->setColumnWidth(2,100);
    tableView3->horizontalHeader()->setStyleSheet("QHeaderView::section{background:rgb(190,190,190);}");
    //设置相邻行颜色交替显示
    tableView3->setAlternatingRowColors(true);
    tableView3->verticalHeader()->hide();    //隐藏默认显示的行头
    tableView3->setSelectionBehavior(QAbstractItemView::SelectRows); //设置选中时整行选中
    tableView3->setEditTriggers(QAbstractItemView::NoEditTriggers);  //设置表格属性只读，不能编辑


    //分区管理
    //添加表头
    standItemModel4->setColumnCount(4);
    standItemModel4->setRowCount(200);
    standItemModel4->setHeaderData(0,Qt::Horizontal,QStringLiteral("进程名"));   //设置表头内容
    standItemModel4->setHeaderData(1,Qt::Horizontal,QStringLiteral("起址"));
    standItemModel4->setHeaderData(2,Qt::Horizontal,QStringLiteral("长度"));
    standItemModel4->setHeaderData(3,Qt::Horizontal,QStringLiteral("状态"));


    //挂载表格模型
    tableView4->setModel(standItemModel4);


    //设置表格属性
    tableView4->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);        //表头信息显示居中
    tableView4->horizontalHeader()->setSectionResizeMode(0,QHeaderView::Fixed);  //设定表头列宽不可变
    tableView4->horizontalHeader()->setSectionResizeMode(1,QHeaderView::Fixed);
    tableView4->horizontalHeader()->setSectionResizeMode(2,QHeaderView::Fixed);
    tableView4->horizontalHeader()->setSectionResizeMode(3,QHeaderView::Fixed);
    tableView4->setColumnWidth(0,80);       //设定表格第0列宽度
    tableView4->setColumnWidth(1,80);
    tableView4->setColumnWidth(2,80);
    tableView4->setColumnWidth(3,80);
    tableView4->horizontalHeader()->setStyleSheet("QHeaderView::section{background:rgb(190,190,190);}");
    //设置相邻行颜色交替显示
    tableView4->setAlternatingRowColors(true);
//    tableView4->verticalHeader()->hide();    //隐藏默认显示的行头
    //初始化
    for(int i=0;i< 200;i++)
    {
    
        QString z = QString::number(0);
        standItemModel4->setItem(i, 0, new QStandardItem(z));
        standItemModel4->setItem(i, 1, new QStandardItem(z));
        standItemModel4->setItem(i, 2, new QStandardItem(z));
        standItemModel4->setItem(i, 3, new QStandardItem(z));
    }
    for(int i = 0;i<10;i++)
    {
    
        QString size = QString::number(i+1);
        QString location = QString::number(0);
        QString status = QString::number(1);
        standItemModel4->setItem(i, 0, new QStandardItem("操作系统"));
        standItemModel4->setItem(i, 1, new QStandardItem(location));
        standItemModel4->setItem(i, 2, new QStandardItem(size));
        standItemModel4->setItem(i, 3, new QStandardItem(status));
    }
    tableView4->setSelectionBehavior(QAbstractItemView::SelectRows); //设置选中时整行选中
    tableView4->setEditTriggers(QAbstractItemView::NoEditTriggers);  //设置表格属性只读，不能编辑
}


//挂起按钮的槽
void Widget::clickGuaqi()
{
    
    int curRow = tableView2->currentIndex().row();
    if(curRow == -1)
    {
    
        QMessageBox::warning(this, "warning", "您没有选择进程！");
    }
    else
    {
    
        QAbstractItemModel *modessl = tableView2->model();
        QModelIndex index = modessl->index(curRow,0);
        QString name = modessl->data(index).toString();
        qDebug()<<name;
        PCB p;
        p = returnPCB(name);
        guaqi.append(p);
        ready.removeAt(getReadyIndex(p));
        updateGuaqiTable();
        updateReadyTable();
        updateMemoryTable();
    }
}


//解挂按钮的槽
void Widget::clickJiegua()
{
    
    int curRow = tableView3->currentIndex().row();
    if(curRow == -1)
    {
    
        QMessageBox::warning(this, "warning", "您没有选择进程！");
    }
    else
    {
    
        QAbstractItemModel *modessl = tableView3->model();
        QModelIndex index = modessl->index(curRow,0);
        QString name = modessl->data(index).toString();


        PCB p;
        p = returnPCB(name);
        guaqi.removeAt(getGuaqiIndex(p));
        ready.append(p);
        updateGuaqiTable();
        updateReadyTable();
        updateMemoryTable();
    }
}


//运行按钮的槽
void Widget::clickRun()
{
    
    if(ready.isEmpty()&& wait.isEmpty())
    {
    
        QMessageBox::warning(this, "warning", "当前没有进程！");
    }
    else
    {
    
        PCB p = ready[0];
        QString str = QString::number(p.getPriority());
        QString t = QString::number(p.getTime());
        nameEdit->setText(p.getName());
        priorityEdit->setText(str);
        timeEdit->setText(t);


        p.setPriority(p.getPriority()-1);
        p.setTime(p.getTime()-1);
        p.setStatus(4);
        updateMemoryTable();
        enter(p);
    }


}


//结束按钮的槽
void Widget::clickFinish()
{
    
    ready.clear();
    wait.clear();
    guaqi.clear();
    for(int i = 0;i < wait.size();i++)
    {
    
        wait.removeAt(i);
    }
    for(int i = 0;i < ready.size();i++)
    {
    
        ready.removeAt(i);
    }
    for(int i = 0;i < guaqi.size();i++)
    {
    
        guaqi.removeAt(i);
    }
    standItemModel->clear();
    standItemModel2->clear();
    standItemModel3->clear();
    initTable();


    nameEdit->clear();
    priorityEdit->clear();
    timeEdit->clear();


    accessBtn->setHidden(false);
    amazonBtn->setHidden(false);
    androidBtn->setHidden(false);
    baidumapBtn->setHidden(false);
    beingBtn->setHidden(false);
    cBtn->setHidden(false);
    chromeBtn->setHidden(false);
    cloudBtn->setHidden(false);
    excelBtn->setHidden(false);
    firefoxBtn->setHidden(false);
    javaBtn->setHidden(false);
    officeBtn->setHidden(false);
    onenoteBtn->setHidden(false);
    pptBtn->setHidden(false);
    pythonBtn->setHidden(false);
    qqBtn->setHidden(false);
    qtBtn->setHidden(false);
    safariBtn->setHidden(false);
    wechatBtn->setHidden(false);
    wordBtn->setHidden(false);
}


//增加按钮的槽
void Widget::clickAccess()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(accessPCB);
        qDebug()<<"ok="<<a;
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            accessPCB.setMemorylocation(a);
            accessBtn->setHidden(true);
            enter(accessPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickAmazon()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(amazonPCB);
        qDebug()<<"ok="<<a;
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            amazonPCB.setMemorylocation(a);
            amazonBtn->setHidden(true);
            enter(amazonPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickAndroid()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(androidPCB);
        qDebug()<<"ok="<<a;
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            androidPCB.setMemorylocation(a);
            androidBtn->setHidden(true);
            enter(androidPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickBaidumap()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(baidumapPCB);
        qDebug()<<"ok="<<a;
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            baidumapPCB.setMemorylocation(a);
            baidumapBtn->setHidden(true);
            enter(baidumapPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickBeing()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(beingPCB);
        qDebug()<<"ok="<<a;
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            beingPCB.setMemorylocation(a);
            beingBtn->setHidden(true);
            enter(beingPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickC()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(cPCB);
        qDebug()<<"ok="<<a;
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            cPCB.setMemorylocation(a);
            cBtn->setHidden(true);
            enter(cPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickChrome()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(chromePCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            chromePCB.setMemorylocation(a);
            chromeBtn->setHidden(true);
            enter(chromePCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickCloud()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(cloudPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            cloudPCB.setMemorylocation(a);
            cloudBtn->setHidden(true);
            enter(cloudPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickExcel()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(excelPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            excelPCB.setMemorylocation(a);
            excelBtn->setHidden(true);
            enter(excelPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickFirefox()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(firefoxPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            firefoxPCB.setMemorylocation(a);
            firefoxBtn->setHidden(true);
            enter(firefoxPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickJava()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(javaPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            javaPCB.setMemorylocation(a);
            javaBtn->setHidden(true);
            enter(javaPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickOffice()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(officePCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            officePCB.setMemorylocation(a);
            officeBtn->setHidden(true);
            enter(officePCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickOnenote()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(onenotePCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            onenotePCB.setMemorylocation(a);
            onenoteBtn->setHidden(true);
            enter(onenotePCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickPPT()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(pptPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            pptPCB.setMemorylocation(a);
            pptBtn->setHidden(true);
            enter(pptPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickPython()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(pythonPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            pythonPCB.setMemorylocation(a);
            pythonBtn->setHidden(true);
            enter(pythonPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickQQ()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(qqPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            qqPCB.setMemorylocation(a);
            qqBtn->setHidden(true);
            enter(qqPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickQt()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(qtPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            qtPCB.setMemorylocation(a);
            qtBtn->setHidden(true);
            enter(qtPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickSafari()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(safariPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            safariPCB.setMemorylocation(a);
            safariBtn->setHidden(true);
            enter(safariPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickWechat()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(wechatPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            wechatPCB.setMemorylocation(a);
            wechatBtn->setHidden(true);
            enter(wechatPCB);
            updateMemoryTable();
        }
    }
}


void Widget::clickWord()
{
    
    int ok = QMessageBox::question(this, "Question", "确定增加这个进程吗？", QMessageBox::Yes | QMessageBox::No);
    if(ok == QMessageBox::Yes)
    {
    
        int a = isOk(wordPCB);
        if(a == 0)
        {
    
            QMessageBox::warning(this, "warning", "内存不足！");
        }
        else
        {
    
            wordPCB.setMemorylocation(a);
            wordBtn->setHidden(true);
            enter(wordPCB);
            updateMemoryTable();
        }
    }
}




//就绪队列表格
void Widget::updateReadyTable()
{
    
    ready = listSort(ready);
    //清空
    standItemModel2->clear();
    initTable();
    updateMemoryTable();
    //重写
    for(int i = 0;i < ready.size();i++)
    {
    
        QString str = QString::number(ready[i].getPriority());
        QString t = QString::number(ready[i].getTime());
        standItemModel2->setItem(i, 0, new QStandardItem(ready[i].getName()));
        standItemModel2->setItem(i, 1, new QStandardItem(str));
        standItemModel2->setItem(i, 2, new QStandardItem(t));
    }
}


//后备队列表格
void Widget::updateWaitTable()
{
    
    wait = listSort(wait);
    //清空
    standItemModel->clear();
    initTable();
    updateMemoryTable();
    //重写
    for(int i = 0;i < wait.size();i++)
    {
    
        QString str = QString::number(wait[i].getPriority());
        QString t = QString::number(wait[i].getTime());
        standItemModel->setItem(i, 0, new QStandardItem(wait[i].getName()));
        standItemModel->setItem(i, 1, new QStandardItem(str));
        standItemModel->setItem(i, 2, new QStandardItem(t));
    }
}


//挂起表格更新
void Widget::updateGuaqiTable()
{
    
    //清空
    standItemModel3->clear();
    initTable();
    updateMemoryTable();
    //重写
    for(int i = 0;i < guaqi.size();i++)
    {
    
        QString str = QString::number(guaqi[i].getPriority());
        QString t = QString::number(guaqi[i].getTime());
        standItemModel3->setItem(i, 0, new QStandardItem(guaqi[i].getName()));
        standItemModel3->setItem(i, 1, new QStandardItem(str));
        standItemModel3->setItem(i, 2, new QStandardItem(t));
    }
}


void Widget::updateMemoryTable()
{
    
    //清空
    standItemModel4->clear();
    initTable();
    int test = ready.size()+wait.size()+guaqi.size();
    qDebug()<<"Size = "<<test;
    //重写
    if(ready.size()+guaqi.size()+wait.size()<=ways)
    {
    
        for(int i = 0;i<ready.size()+guaqi.size();i++)
        {
    
            for(int m = 0;m<ready.size();m++)
            {
    
                int s = ready[m].getMemorylocation();
                for(int j = 0;j < ready[m].getMemorySize();j++)
                {
    
                    QString location = QString::number(ready[m].getMemorylocation());
                    QString size = QString::number(j+1);
                    QString status = QString::number(1);
                    standItemModel4->setItem(s+j, 0, new QStandardItem(ready[m].getName()));
                    standItemModel4->setItem(s+j, 1, new QStandardItem(location));
                    standItemModel4->setItem(s+j, 2, new QStandardItem(size));
                    standItemModel4->setItem(s+j, 3, new QStandardItem(status));
                }
            }
            for(int m = 0;m<guaqi.size();m++)
            {
    
                int s = guaqi[m].getMemorylocation();
                for(int j = 0;j < guaqi[m].getMemorySize();j++)
                {
    
                    QString location = QString::number(guaqi[m].getMemorylocation());
                    QString size = QString::number(j+1);
                    QString status = QString::number(1);
                    standItemModel4->setItem(s+j, 0, new QStandardItem(guaqi[m].getName()));
                    standItemModel4->setItem(s+j, 1, new QStandardItem(location));
                    standItemModel4->setItem(s+j, 2, new QStandardItem(size));
                    standItemModel4->setItem(s+j, 3, new QStandardItem(status));
                }
            }
        }
    }
    else
    {
    
        qDebug()<<"进入成功 ";
        for(int i = 0;i < ready.size()+wait.size()+guaqi.size();i++)
        {
    
            if(i<ways)
            {
    
                for(int m = 0;m<ready.size();m++)
                {
    
                    int s = ready[m].getMemorylocation();
                    for(int j = 0;j < ready[m].getMemorySize();j++)
                    {
    
                        QString location = QString::number(ready[m].getMemorylocation());
                        QString size = QString::number(j+1);
                        QString status = QString::number(1);
                        standItemModel4->setItem(s+j, 0, new QStandardItem(ready[m].getName()));
                        standItemModel4->setItem(s+j, 1, new QStandardItem(location));
                        standItemModel4->setItem(s+j, 2, new QStandardItem(size));
                        standItemModel4->setItem(s+j, 3, new QStandardItem(status));
                    }
                }
                for(int m = 0;m<guaqi.size();m++)
                {
    
                    int s = guaqi[m].getMemorylocation();
                    for(int j = 0;j < guaqi[m].getMemorySize();j++)
                    {
    
                        QString location = QString::number(guaqi[m].getMemorylocation());
                        QString size = QString::number(j+1);
                        QString status = QString::number(1);
                        standItemModel4->setItem(s+j, 0, new QStandardItem(guaqi[m].getName()));
                        standItemModel4->setItem(s+j, 1, new QStandardItem(location));
                        standItemModel4->setItem(s+j, 2, new QStandardItem(size));
                        standItemModel4->setItem(s+j, 3, new QStandardItem(status));
                    }
                }
            }
            else
            {
    
                int m = i-ways;
                int s = wait[m].getMemorylocation();
                QString status = QString::number(1);
                for(int j=0;j<wait[m].getMemorySize();j++)
                {
    
                    QString location = QString::number(wait[m].getMemorylocation());
                    QString size = QString::number(j+1);
                    standItemModel4->setItem(s+j, 0, new QStandardItem(wait[m].getName()));
                    standItemModel4->setItem(s+j, 1, new QStandardItem(location));
                    standItemModel4->setItem(s+j, 2, new QStandardItem(size));
                    standItemModel4->setItem(s+j, 3, new QStandardItem(status));
                }
            }
        }
    }
}


void Widget::enter(PCB p)
{
    
    int flag = ready.size() + guaqi.size();
    if(p.getStatus() == 1)
    {
    
        if(flag< ways && wait.isEmpty())
        {
    
            ready.append(p);


            updateReadyTable();
        }
        else
        {
    
            wait.append(p);


            updateWaitTable();
        }
    }
    else if(p.getStatus() == 4)
    {
    


        if(flag == ways && flag >=1 && !wait.isEmpty())
        {
    //如果就绪队列少一，从后备中加一
            ready.removeFirst();
            ready.append(wait[0]);
            wait.removeFirst();
            updateReadyTable();
            updateWaitTable();
        }
        else
        {
    
            ready.removeFirst();
            updateReadyTable();
        }


        //时间
        if(p.getTime() > 0)
        {
    
            p.setStatus(1);
            enter(p);
        }
        else
        {
    
            finishName = p.getName();
            refreshBtn();
            QMessageBox::warning(this,"finish",QString(tr("%1已结束").arg(finishName)));
            QString status = QString::number(0);
            for(int i = 0;i < 200;i++)
            {
    
                QString s = standItemModel4->item(i,0)->text();
//                qDebug()<<s;
                if(s == finishName)
                {
    
                    standItemModel4->setItem(i, 0, new QStandardItem(status));
                    standItemModel4->setItem(i, 1, new QStandardItem(status));
                    standItemModel4->setItem(i, 2, new QStandardItem(status));
                    standItemModel4->setItem(i, 3, new QStandardItem(status));
                }
            }
        }
    }
}


void Widget::initPCB()
{
    
    //PCB数据
    accessPCB.setName("Access");
    accessPCB.setPriority(1);
    accessPCB.setTime(2);
    accessPCB.setStatus(1);
    accessPCB.setMemorySize(5);
//    accessPCB.setMemorylocation(0);


    //PCB数据
    amazonPCB.setName("Amazon");
    amazonPCB.setPriority(2);
    amazonPCB.setTime(3);
    amazonPCB.setStatus(1);
    amazonPCB.setMemorySize(10);


    //PCB数据
    androidPCB.setName("Android");
    androidPCB.setPriority(3);
    androidPCB.setTime(5);
    androidPCB.setStatus(1);
    androidPCB.setMemorySize(15);


    //PCB数据
    baidumapPCB.setName("Baidu Map");
    baidumapPCB.setPriority(4);
    baidumapPCB.setTime(1);
    baidumapPCB.setStatus(1);
    baidumapPCB.setMemorySize(20);


    //PCB数据
    beingPCB.setName("Being");
    beingPCB.setPriority(1);
    beingPCB.setTime(4);
    beingPCB.setStatus(1);
    beingPCB.setMemorySize(25);
    //PCB数据
    cPCB.setName("C++");
    cPCB.setPriority(2);
    cPCB.setTime(6);
    cPCB.setStatus(1);
    cPCB.setMemorySize(72);


    //PCB数据
    chromePCB.setName("Chrome");
    chromePCB.setPriority(3);
    chromePCB.setTime(2);
    chromePCB.setStatus(1);
    chromePCB.setMemorySize(64);
    //PCB数据
    cloudPCB.setName("Cloud");
    cloudPCB.setPriority(4);
    cloudPCB.setTime(3);
    cloudPCB.setStatus(1);
    cloudPCB.setMemorySize(56);


    //PCB数据
    excelPCB.setName("Excel");
    excelPCB.setPriority(1);
    excelPCB.setTime(5);
    excelPCB.setStatus(1);
    excelPCB.setMemorySize(48);


    //PCB数据
    firefoxPCB.setName("Fire Fox");
    firefoxPCB.setPriority(2);
    firefoxPCB.setTime(1);
    firefoxPCB.setStatus(1);
    firefoxPCB.setMemorySize(40);


    //PCB数据
    javaPCB.setName("Java");
    javaPCB.setPriority(3);
    javaPCB.setTime(4);
    javaPCB.setStatus(1);
    javaPCB.setMemorySize(32);


    //PCB数据
    officePCB.setName("Office");
    officePCB.setPriority(4);
    officePCB.setTime(6);
    officePCB.setStatus(1);
    officePCB.setMemorySize(24);


    //PCB数据
    onenotePCB.setName("One Note");
    onenotePCB.setPriority(1);
    onenotePCB.setTime(2);
    onenotePCB.setStatus(1);
    onenotePCB.setMemorySize(16);


    //PCB数据
    pptPCB.setName("PPT");
    pptPCB.setPriority(2);
    pptPCB.setTime(3);
    pptPCB.setStatus(1);
    pptPCB.setMemorySize(8);


    //PCB数据
    pythonPCB.setName("Python");
    pythonPCB.setPriority(3);
    pythonPCB.setTime(5);
    pythonPCB.setStatus(1);
    pythonPCB.setMemorySize(9);


    //PCB数据
    qqPCB.setName("QQ");
    qqPCB.setPriority(4);
    qqPCB.setTime(1);
    qqPCB.setStatus(1);
    qqPCB.setMemorySize(36);


    //PCB数据
    qtPCB.setName("QT");
    qtPCB.setPriority(1);
    qtPCB.setTime(4);
    qtPCB.setStatus(1);
    qtPCB.setMemorySize(45);


    //PCB数据
    safariPCB.setName("Safari");
    safariPCB.setPriority(2);
    safariPCB.setTime(6);
    safariPCB.setStatus(1);
    safariPCB.setMemorySize(5);


    //PCB数据
    wechatPCB.setName("WeChat");
    wechatPCB.setPriority(3);
    wechatPCB.setTime(2);
    wechatPCB.setStatus(1);
    wechatPCB.setMemorySize(27);


    //PCB数据
    wordPCB.setName("Word");
    wordPCB.setPriority(4);
    wordPCB.setTime(3);
    wordPCB.setStatus(1);
    wordPCB.setMemorySize(54);
}


void Widget::refreshBtn()
{
    
    if(finishName == "Access")
    {
    
        accessBtn->setHidden(false);
    }
    else if(finishName == "Amazon")
    {
    
        amazonBtn->setHidden(false);
    }
    else if(finishName == "Android")
    {
    
        androidBtn->setHidden(false);
    }
    else if(finishName == "Baidu Map")
    {
    
        baidumapBtn->setHidden(false);
    }
    else if(finishName == "Being")
    {
    
        beingBtn->setHidden(false);
    }
    else if(finishName == "C++")
    {
    
        cBtn->setHidden(false);
    }
    else if(finishName == "Chrome")
    {
    
        chromeBtn->setHidden(false);
    }
    else if(finishName == "Cloud")
    {
    
        cloudBtn->setHidden(false);
    }
    else if(finishName == "Excel")
    {
    
        excelBtn->setHidden(false);
    }
    else if(finishName == "Fire Fox")
    {
    
        firefoxBtn->setHidden(false);
    }
    else if(finishName == "Java")
    {
    
        javaBtn->setHidden(false);
    }
    else if(finishName == "Office")
    {
    
        officeBtn->setHidden(false);
    }
    else if(finishName == "One Note")
    {
    
        onenoteBtn->setHidden(false);
    }
    else if(finishName == "PPT")
    {
    
        pptBtn->setHidden(false);
    }
    else if(finishName == "Python")
    {
    
        pythonBtn->setHidden(false);
    }
    else if(finishName == "QQ")
    {
    
        qqBtn->setHidden(false);
    }
    else if(finishName == "QT")
    {
    
        qtBtn->setHidden(false);
    }
    else if(finishName == "Safari")
    {
    
        safariBtn->setHidden(false);
    }
    else if(finishName == "WeChat")
    {
    
        wechatBtn->setHidden(false);
    }
    else if(finishName == "Word")
    {
    
        wordBtn->setHidden(false);
    }
}


QList<PCB> Widget::listSort(QList<PCB> l)
{
    
    QList<PCB> list;
    list = l;
    for(int i = list.size()-1;i >0;i--)
    {
    
        if(list[i-1].getPriority() < list[i].getPriority())
        {
    
            list.swap(i-1,i);
        }
    }
    return list;
}


PCB Widget::returnPCB(QString name)
{
    
    if(name == "Access")
    {
    
        return accessPCB;
    }
    else if(name == "Amazon")
    {
    
        return amazonPCB;
    }
    else if(name == "Android")
    {
    
        return androidPCB;
    }
    else if(name == "Baidu Map")
    {
    
        return baidumapPCB;
    }
    else if(name == "Being")
    {
    
        return beingPCB;
    }
    else if(name == "C++")
    {
    
        return cPCB;
    }
    else if(name == "Chrome")
    {
    
        return chromePCB;
    }
    else if(name == "Cloud")
    {
    
        return cloudPCB;
    }
    else if(name == "Excel")
    {
    
        return excelPCB;
    }
    else if(name == "Fire Fox")
    {
    
        return firefoxPCB;
    }
    else if(name == "Java")
    {
    
        return javaPCB;
    }
    else if(name == "Office")
    {
    
        return officePCB;
    }
    else if(name == "One Note")
    {
    
        return onenotePCB;
    }
    else if(name == "PPT")
    {
    
        return pptPCB;
    }
    else if(name == "Python")
    {
    
        return pythonPCB;
    }
    else if(name == "QQ")
    {
    
        return qqPCB;
    }
    else if(name == "QT")
    {
    
        return qtPCB;
    }
    else if(name == "Safari")
    {
    
        return safariPCB;
    }
    else if(name == "WeChat")
    {
    
        return wechatPCB;
    }
    else if(name == "Word")
    {
    
        return wordPCB;
    }
}


int Widget::getReadyIndex(PCB p)
{
    
    for(int i = 0;i < ready.size();i++)
    {
    
        if(p.getName() == ready[i].getName())
        {
    
            return i;
        }
    }
}


int Widget::getGuaqiIndex(PCB p)
{
    
    for(int i = 0;i < guaqi.size();i++)
    {
    
        if(p.getName() == guaqi[i].getName())
        {
    
            return i;
        }
    }
}


int Widget::isOk(PCB p)
{
    
    int flag1 = 0;
    int l = 0;
    int pSize = p.getMemorySize();
    int count = 0;
    for(int i = 10 ; i<200-pSize; i++)
    {
    
        QString str =standItemModel4->item(i,3)->text();
        int s = str.toInt();
        if(s == 0)
        {
    
            count = 0;
            for(int j = 0; j<pSize;j++)
            {
    
                QString str1 =standItemModel4->item(j+i,3)->text();
                int s1 = str1.toInt();
                if(s1 == 0)
                {
    
                    count++;
                }
            }
            if(count == pSize)
            {
    
                flag1 = 1;
                l = i;
                break;
            }
            else
            {
    
                flag1 = 0;
                l=i;
                continue;
            }
        }
    }
    if(flag1 == 0)
    {
    
        qDebug()<<"flag1="<<flag1;
        qDebug()<<p.getName()<<" l="<<l;
        qDebug()<<"count="<<count;
        return 0;
    }
    else
    {
    
        qDebug()<<"flag1="<<flag1;
        qDebug()<<p.getName()<<" l="<<l;
        qDebug()<<"count="<<count;
        return l;
    }
}

main.cpp

#include "widget.h"
#include <QApplication>
#include <QTableView>
#include <QStandardItemModel>
#include <QHeaderView>
#include <QPalette>
#include <QString>
#include <QIcon>
#include <QBrush>
#include <QPixmap>
int main(int argc, char *argv[])
{
    
    QApplication a(argc, argv);
    Widget w;
    w.setAutoFillBackground(true);
    w.resize(1800,900);
    w.setWindowTitle(QString("进程调度"));
    QPalette palette;
    QPixmap pixmap("images/sky.jpg");//背景
    palette.setBrush(QPalette::Window, QBrush(pixmap));
    w.setWindowIcon(QIcon(":/image/images/run.ico"));
    w.setPalette(palette);


    w.show();


    return a.exec();
}

实验小结

实验一

① 本次实验过程中，最重要的是理清楚CPU调度的整个过程，对于进程进入时进入的队列有一定的了解

② 本实验仅仅是模拟CPU调度，可以在动态的图形化界面中感受其调度过程，但是内部逻辑方面与真实的CPU调度仍旧略有差距

③ 本实验的一个优势为逻辑较为清晰，且每一个功能的实现分割较为明确

④ 在本次实验过程中，发现Qt的调试工具不是非常的好用，所以灵活应用qDebug()是检验错误的一个好方法

实验二

① 本次实验过程中，最重要的是理清楚可变分区分配的整个过程，对于进程进入时内存内容有一定的了解

② 本实验仅仅是模拟可变分区分配，可以在动态的图形化界面中感受过程，但是内部逻辑方面与真实的可变分区分配仍旧略有差距

③ 本实验的一个优势为逻辑较为清晰，且每一个功能的实现分割较为明确

④ 在本次实验过程中，发现Qt的调试工具不是非常的好用，所以灵活应用qDebug()是检验错误的一个好方法

⑤ 本实验未实现紧缩功能，可以持续改进

⑥ 本实验中可用分区的合并通过表格可以直接实现