操作系统相关课设

实验一 动态资源分配算法模拟--银行家算法

实验二 通用处理机调度演示程序

实验三 多进程同步模拟--桔子苹果问题

实验四 存储管理动态分配算法模拟

实验五 存储管理之虚拟存储器模拟--页面置换算法

实验六 文件系统设计

实验七 磁盘调度管理

实验八 进程间通信

实验1：

实验要求

1.资源种类与数目可在界面进行设置，在资源分配过程中可以随时增加进程及其对资源的需求。

2.可读取样例数据（要求存放在外部文件中）进行资源种类、数目与进程数的初始化。

3.在资源分配过程中可以随时进行系统安全状态检测。

4.如果能够通过系统安全状态检测，则系统对该进程进行资源分配；当进程满足所有资源分配后能够

自行释放所有资源，退出资源竞争。

5.要求进行安全性检查时按指定策略顺序进行，即按每个进程当前 Need 数由小至大进行排序，如果

Need 数相同，则按序号由小至大进行排序；

6.具有一定的数据容错性。

实验2：

实验要求

1. 进程调度算法包括：时间片轮转算法、先来先服务算法、短作业优先算法、静态优先权优先调度算

法、高响应比调度算法 。

2. 每一个进程有一个 PCB，其内容可以根据具体情况设定。

3. 进程数、进入内存时间、要求服务时间、作业大小、优先级等均可以在界面上设定。

4. 可读取样例数据（要求存放在外部文件中）进行进程数、进入内存时间、时间片长度、作业大小、

进程优先级的初始化

5. 可以在运行中显示各进程的状态：就绪、执行（由于不要求设置互斥资源与进程间的同步关系，故

只有两种状态）

6. 采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态及相应的阻塞队列。

7. 有性能比较功能，可比较同一组数据在不同调度算法下的平均周转时间

实验3：

有两类生产者，一类负责生产桔子，一类负责生产苹果；有两类消费者，一类负责消费桔

子，一类负责消费苹果；他们共享一个有 20 个存储单元的有界缓冲区，每个存储单元只能放入一种产品

（桔子/苹果）。

实验4：设计主界面以灵活选择某算法，且以下算法都要实现：首次适应算法、循环首次适应算法、最佳适应算法；

实验5：

编程序实现先进先出算法（FIFO）、最近最久未使用算法（LRU）算法、最佳置换算法（OPT）的具体实现过程，并计算访问命中率。

实验6：

设计文件系统的数据结构和数据结构间的关系，设计文件的基本操作算法，完成系统的总控模块编程和各个操作模块编程。上机测试各个模块，没执行一个操作，打印有关数据结构的内容，判断操作的正确性。

实验7：

设计一个磁盘调度系统，针对磁盘访问序列，可以选择先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）来实现。

实验8：

三、实验要求

（1）当两个进程通信时需满足进程同步机制。

（2）当多个进程（大于 2）通信时需使用信号量机制实现互斥操作。

（3）编程语言不限。

具体代码如下：

实验1：

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>  // for accumulate
#include <fstream>
#include <string>

using namespace std;

struct Process {
    string pName;                                                        // 进程名
    vector<int> Max;                                                     // 最大需求矩阵,每种资源的最大需求
    vector<int> Need;                                                    // 需求矩阵，每种资源还需要多少
    vector<int> Allocation;                                              // 分配矩阵，已经分配的每种资源数量
    bool Finish;                                                         // 进程是否完成（用于安全性检查）
};

struct Resource {
    vector<string> rName;                                                // 资源名
    vector<int> Total;                                                   // 资源总数
    vector<int> Available;                                               // 可利用资源
    vector<int> Work;                                                    // 工作向量（用于安全性检查）
    vector<int> Request;
};

int processNum = 0;               // 进程数量
int systemResourceNum = 0;        // 系统资源数量
vector<Process> pcb;              // 进程控制块（所有进程的集合）
Resource resource;                // 资源
vector<vector<int>> allSafeSequence;  // 所有安全序列

void showMenu();
void getData();//从文件中读取初始数据，初始化进程和资源的状态。
void displayCurrentStatus(); //显示当前资源分配状态，包括每个进程的最大需求、分配、需求、可利用资源和完成状态。
void bankerAlgorithm();
void isSafe();
void dfs(int count, vector<int>& temp);//深度优先搜索，找出所有可能的安全序列。
void printSafeSequence();
void requestResource();//处理资源请求，判断请求是否合法，并更新系统状态。
void addProcess();
void findAllSafeSequence();//调用DFS找到所有安全序列。
void displayEndStatus();//显示最终资源分配状态。
void printAllSafeSequence();
void sortProcessesByNeed();//按需求矩阵对进程进行排序

int main() {
  
    getData();
    showMenu();
    int choice;
    while (true) {
        cout << "请输入选择的操作: ";
        cin >> choice;
        switch (choice) {
        case 1:
            displayCurrentStatus();
            break;
        case 2:
            requestResource();
            bankerAlgorithm();
            displayEndStatus();
            break;
        case 3:
            printSafeSequence();
            break;
        case 4:
            addProcess();
            break;
        case 0:
            exit(0);
        default:
            cout << "无效的选择，请重新输入!" << endl;
            break;
        }
    }
    return 0;
}

void showMenu() {
    cout << "*********** 银行家算法 ***********" << endl;
    cout << "******* 1. 显示当前资源状态 *******" << endl;
    cout << "******* 2. 请求资源 ***************" << endl;
    cout << "******* 3. 输出安全序列 ***********" << endl;
    cout << "******* 4. 增加进程 ****************" << endl;
    cout << "******* 0. 结束程序 ***************" << endl;
}

void getData() {
    ifstream inFile("C:\\Users\\DELL\\Desktop\\新建文件夹\\新建 文本文档.txt");
    if (!inFile) {
        cerr << "无法打开文件!" << endl;
        exit(1);
    }

    inFile >> processNum >> systemResourceNum;
    pcb.resize(processNum);

    for (int i = 0; i < processNum; i++) {
        pcb[i].pName = "P" + to_string(i);
        pcb[i].Max.resize(systemResourceNum);
        pcb[i].Need.resize(systemResourceNum);
        pcb[i].Allocation.resize(systemResourceNum);
        pcb[i].Finish = false;

        for (int j = 0; j < systemResourceNum; j++) {
            inFile >> pcb[i].Max[j];
        }
    }

    for (int i = 0; i < processNum; i++) {
        for (int j = 0; j < systemResourceNum; j++) {
            inFile >> pcb[i].Allocation[j];
            pcb[i].Need[j] = pcb[i].Max[j] - pcb[i].Allocation[j];
        }
    }

    resource.rName.resize(systemResourceNum);
    for (int i = 0; i < systemResourceNum; i++) {
        inFile >> resource.rName[i];
    }

    resource.Total.resize(systemResourceNum);
    for (int i = 0; i < systemResourceNum; i++) {
        inFile >> resource.Total[i];
    }

    resource.Available.resize(systemResourceNum);
    for (int j = 0; j < systemResourceNum; j++) {
        int totalAllocation = 0;
        for (int i = 0; i < processNum; i++) {
            totalAllocation += pcb[i].Allocation[j];
        }
        resource.Available[j] = resource.Total[j] - totalAllocation;
    }

    inFile.close();
}

void displayCurrentStatus() {
    cout << "进程 | 最大需求 | 分配 | 需求 | 可利用资源 | 状态" << endl;
    for (int i = 0; i < processNum; i++) {
        cout << pcb[i].pName << " | ";
        for (int j = 0; j < systemResourceNum; j++) {
            cout << pcb[i].Max[j] << " ";
        }
        cout << "| ";
        for (int j = 0; j < systemResourceNum; j++) {
            cout << pcb[i].Allocation[j] << " ";
        }
        cout << "| ";
        for (int j = 0; j < systemResourceNum; j++) {
            cout << pcb[i].Need[j] << " ";
        }
        cout << "| ";
        if (i == 0) {
            for (int j = 0; j < systemResourceNum; j++) {
                cout << resource.Available[j] << " ";
            }
        }
        cout << "| " << (pcb[i].Finish ? "true" : "false") << endl;
    }
}

void requestResource() {//request<=need.request<=avaliable,系统试探分配，且，available-=request,allocation+=request
    resource.Request.resize(systemResourceNum);
    int processID;
    cout << "请输入提出请求的进程号(从0开始编号): ";
    cin >> processID;
    cout << "请输入进程" << pcb[processID].pName << "请求的资源数: ";
    for (int i = 0; i < systemResourceNum; i++) {
        cin >> resource.Request[i];
    }

    for (int i = 0; i < systemResourceNum; i++) {
        if (resource.Request[i] > pcb[processID].Need[i]) {
            cout << "所需的资源数已经超过申请的最大值。" << endl;
            return;
        }
    }

    for (int i = 0; i < systemResourceNum; i++) {
        if (resource.Request[i] > resource.Available[i]) {
            cout << "没有足够的资源，进程" << pcb[processID].pName << "需要等待" << endl;
            return;
        }
    }

    for (int i = 0; i < systemResourceNum; i++) {
        resource.Available[i] -= resource.Request[i];
        pcb[processID].Allocation[i] += resource.Request[i];
        pcb[processID].Need[i] -= resource.Request[i];
    }
}

void bankerAlgorithm() {
    sortProcessesByNeed();
    isSafe();
}

void isSafe() {//遍历所有进程，finish=true，安全
    vector<int> work = resource.Available;
    vector<int> safeSequence;
    vector<bool> finish(processNum, false);

    while (safeSequence.size() < processNum) {
        bool found = false;
        for (int i = 0; i < processNum; i++) {
            if (!finish[i]) {
                bool canAllocate = true;
                for (int j = 0; j < systemResourceNum; j++) {
                    if (pcb[i].Need[j] > work[j]) {
                        canAllocate = false;
                        break;
                    }
                }
                if (canAllocate) {
                    for (int j = 0; j < systemResourceNum; j++) {
                        work[j] += pcb[i].Allocation[j];
                    }
                    finish[i] = true;
                    safeSequence.push_back(i);
                    found = true;
                }
            }
        }
        if (!found) {
            cout << "系统不安全，无法分配资源。" << endl;
            return;
        }
    }

    cout << "系统安全，安全序列为: ";
    for (int i : safeSequence) {
        cout << pcb[i].pName << " ";
    }
    cout << endl;
}

void addProcess() {//Max,allocation,得出need,avliable-=allocation
    Process newProcess;
    newProcess.pName = "P" + to_string(processNum);
    newProcess.Max.resize(systemResourceNum);
    newProcess.Need.resize(systemResourceNum);
    newProcess.Allocation.resize(systemResourceNum);
    newProcess.Finish = false;

    cout << "请输入新进程的最大需求: ";
    for (int i = 0; i < systemResourceNum; i++) {
        cin >> newProcess.Max[i];
    }
    cout << "请输入新进程的当前分配: ";
    for (int i = 0; i < systemResourceNum; i++) {
        cin >> newProcess.Allocation[i];
        newProcess.Need[i] = newProcess.Max[i] - newProcess.Allocation[i];
    }

    pcb.