银行家算法：预防操作系统死锁的C++实现

本文还有配套的精品资源，点击获取

简介：银行家算法是一种用于预防操作系统中死锁的策略，通过模拟银行贷款分配过程，确保系统资源分配的安全性。本文详细介绍了银行家算法的工作原理和C++程序实现，包括初始化系统资源、处理资源请求、进行安全性检查以及资源分配和释放的步骤。程序使用VS2010环境编写，重点在于数据结构设计、文件读取、安全性检查算法、用户界面和程序调试。通过银行家算法的编程实践，可以加深对死锁避免策略的理解。

1. 死锁预防策略概述

死锁是操作系统中常见的问题，它指的是多个进程因竞争资源而造成的一种僵局，即它们无限期地等待对方释放资源。为了避免这种情况的发生，我们需要采取有效的预防策略。死锁预防策略大致可以分为两类：静态分配资源和动态检查机制。静态分配资源，即在系统设计阶段，通过限制并发进程的数量来避免死锁。而动态检查机制，例如银行家算法，通过在资源分配时进行安全状态检查，以确保系统不会进入死锁状态。

在实际操作中，死锁的预防策略需要结合具体的应用场景和系统需求来决定。例如，对于资源利用率要求不高的系统，可能会更倾向于选择静态分配资源的方式来预防死锁，因为这种方式实现简单，维护成本低。而在资源利用率要求较高的系统中，动态检查机制则能提供更大的灵活性和资源利用率。在下一章中，我们将深入探讨银行家算法的原理及其在死锁预防中的应用。

2. 银行家算法原理与实现

2.1 银行家算法的理论基础

2.1.1 死锁的定义和条件

在操作系统中，死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象。若无外力作用，它们都将无法推进下去。典型的死锁状态包括以下四个必要条件：

• 互斥条件：资源不能被多个进程共享，只能由一个进程使用。
• 占有和等待条件：一个进程至少占有一个资源，并且等待获取额外的资源，同时该资源被其他进程占有。
• 不可抢占条件：已经分配给一个进程的资源，不能被强制从该进程中抢占。
• 循环等待条件：存在一种进程资源的循环等待链。

2.1.2 银行家算法的引入和作用

银行家算法由艾兹格·迪杰斯特拉（Edsger Dijkstra）提出，用于避免死锁的发生。其核心思想是在每次资源请求时，先进行安全性检查，只有在系统能够进入安全状态的前提下才分配资源。该算法模拟银行家放贷的模式，能够保证系统在资源分配后，至少存在一个安全序列，使得每个进程都能按某种顺序获得所需资源，从而避免死锁。

2.2 银行家算法的核心概念

2.2.1 可利用资源与最大需求

银行家算法需要跟踪系统的可利用资源和每个进程的最大资源需求。可利用资源指的是当前系统中未被占用且可以被分配给进程的资源总量。每个进程在其生命周期中可能请求的最大资源量称为最大需求。

2.2.2 分配矩阵与需求矩阵

在银行家算法中，使用分配矩阵来表示当前各进程已经分配到的资源数量，而需求矩阵则表示各进程还需要多少资源才能完成任务。这两个矩阵是算法判断进程能否在将来获得所需资源的关键数据结构。

2.2.3 安全状态与死锁避免

安全性是指系统能够在当前资源分配状态下找到一种资源分配序列，使得每个进程都可以顺利完成。系统一旦处于安全状态，就可以避免死锁的发生。银行家算法通过不断地预测和评估来保证系统不进入不安全状态。

2.3 银行家算法的具体实现

2.3.1 算法伪代码

以下是银行家算法的基本伪代码描述：

Bankers_Algorithm(requests):
    for i = 1 to n do
        if requests[i] > need[i][j] then
            return false
        if requests[i] > available[j] then
            return false
    available = available - requests
    allocation = allocation + requests
    let work = available
    let finish = [false, false, ..., false]
    while (exists i: finish[i] == false && work >= need[i]) do
        work = work + allocation[i]
        finish[i] = true
    if all finish[i] == true then
        return true
    else
        return false

2.3.2 安全性检测逻辑

安全性检测的目的是确保系统能够找到一个安全序列，避免死锁。算法模拟进程执行，并尝试释放资源，以此来检查是否存在至少一个进程可以完成执行。如果所有进程都能这样依次完成，系统就处于安全状态。

2.3.3 死锁避免策略

死锁避免的策略是在每次资源请求时，先计算完成该请求后系统的状态，然后使用安全性检测来确定是否分配资源。如果系统保持在安全状态，则允许这次资源请求；如果会进入不安全状态，则拒绝这次请求。这样的策略确保系统不会因为资源分配不当而进入死锁状态。

2.3.4 算法的优化

为了提高银行家算法的效率，可以采取多种优化策略，例如预先计算安全序列、使用更高效的数据结构存储资源信息、并行计算等。通过这些优化，可以在保证系统安全的前提下，提高资源分配的速度和效率。

2.3.5 代码实现示例

下面是一个简化的银行家算法的C++代码实现示例，展示了算法的主体结构：

#include <iostream>
#include <vector>

using namespace std;

// 判断系统是否处于安全状态
bool isSafe(vector<vector<int>>& available, vector<vector<int>>& allocation, vector<vector<int>>& max, vector<int>& need, vector<int>& finish, int numProcess) {
    vector<int> work = available;
    vector<int> temp(numProcess);
    while (true) {
        bool found = false;
        for (int p = 0; p < numProcess; p++) {
            if (!finish[p]) {
                bool possible = true;
                for (int i = 0; i < numProcess; i++) {
                    if (need[p][i] > work[i]) {
                        possible = false;
                        break;
                    }
                }
                if (possible) {
                    for (int i = 0; i < numProcess; i++) {
                        work[i] += allocation[p][i];
                    }
                    finish[p] = true;
                    found = true;
                }
            }
        }
        if (!found) break;
    }
    for (int i = 0; i < numProcess; i++) {
        if (!finish[i]) return false;
    }
    return true;
}

// 主函数，用于测试银行家算法
int main() {
    int numResources = 3, numProcess = 5;
    vector<vector<int>> available = {{3, 3, 2}, {2, 2, 2}, {1, 1, 1}, {0, 0, 0}};
    vector<vector<int>> allocation = {{0, 1, 0}, {2, 0, 0}, {3, 0, 2}, {2, 1, 1}, {0, 0, 2}};
    vector<vector<int>> max = {{7, 5, 3}, {3, 2, 2}, {9, 0, 2}, {2, 2, 2}, {4, 3, 3}};
    vector<int> need(numProcess, vector<int>(numResources));
    for (int i = 0; i < numProcess; i++) {
        for (int j = 0; j < numResources; j++) {
            need[i][j] = max[i][j] - allocation[i][j];
        }
    }

    vector<int> finish(numProcess, 0);
    // 模拟资源请求
    vector<int> request = {1, 0, 2};
    int process = 1; // 假设进程1请求资源

    // 检查请求是否超过最大需求
    for (int i = 0; i < numResources; i++) {
        if (request[i] > need[process][i]) {
            cout << "进程请求超过最大需求，请求被拒绝" << endl;
            return 1;
        }
    }

    // 检查请求是否超过可用资源
    for (int i = 0; i < numResources; i++) {
        if (request[i] > available[i]) {
            cout << "资源不足，请求被延迟" << endl;
            return 1;
        }
    }

    // 尝试分配资源并检查系统是否安全
    for (int i = 0; i < numResources; i++) {
        available[i] -= request[i];
        allocation[process][i] += request[i];
        need[process][i] -= request[i];
    }

    if (isSafe(available, allocation, max, need, finish, numProcess)) {
        cout << "资源请求满足，并且系统处于安全状态" << endl;
    } else {
        // 如果系统不安全，则回滚
        for (int i = 0; i < numResources; i++) {
            available[i] += request[i];
            allocation[process][i] -= request[i];
            need[process][i] += request[i];
        }
        cout << "资源请求导致系统进入不安全状态，请求被拒绝" << endl;
    }
    return 0;
}

在此代码中，我们首先定义了一个 isSafe 函数，用于检测系统是否处于安全状态。在主函数中，我们模拟了一个进程请求资源的过程，并按照银行家算法的步骤进行了安全性检查和资源分配尝试。如果系统无法进入安全状态，则撤销分配操作，并拒绝该请求。这样可以确保系统始终处于安全状态，有效避免死锁的发生。

以上是银行家算法理论与实现的基本介绍，下一节我们将深入探讨C++在银行家算法实现中的具体应用。

3. C++程序设计步骤

3.1 开发环境的搭建与配置

3.1.1 选择合适的编译器和开发工具

选择合适的开发环境是C++程序设计的第一步。对于C++来说，常用的编译器有GCC、Clang和MSVC。GCC和Clang是开源社区广泛使用的编译器，支持各种平台，如Linux、macOS和Windows。MSVC则是Microsoft Visual Studio集成开发环境（IDE）中使用的编译器，特别适合Windows平台的开发。

对于开发工具，Visual Studio为C++开发者提供了全面的支持，包括代码编辑、调试和性能分析。CLion是由JetBrains开发的跨平台C++ IDE，提供了智能代码分析、代码质量保证以及自动化重构等功能。Eclipse CDT是一个开源的IDE插件，适合那些熟悉Eclipse环境的开发者。

3.1.2 设置项目与环境初始化

在选定开发工具后，我们需要进行项目的设置和环境初始化。以Visual Studio为例，创建一个C++项目通常涉及以下步骤：

1. 打开Visual Studio，点击“创建新项目”。
2. 在项目类型中选择“C++”，然后选择合适的项目模板，例如“Windows 控制台应用程序”。
3. 为项目命名并选择项目文件的位置，然后点击“创建”。
4. Visual Studio将自动生成项目结构，并提供一个主函数的模板代码。

接下来是环境的配置。例如，如果需要将第三方库集成到项目中，可能需要修改项目的包含目录（include directories）、库目录（library directories）和链接器输入（Linker input）等配置。在Visual Studio中，可以在项目属性（Properties）的“VC++目录”、“链接器”和“C/C++”选项卡中进行这些配置。

3.2 银行家算法的C++实现

3.2.1 类和对象的定义

在实现银行家算法时，我们可以通过定义类和对象来更好地组织和管理数据结构。首先，我们可以定义几个关键的类：

• Resource 类：表示系统中的每种类型的资源。
• Process 类：表示一个进程，包含进程标识符和该进程对资源的最大需求。
• BankersAlgorithm 类：核心算法实现类，负责资源分配和安全性检查。

下面是 BankersAlgorithm 类的一个简单定义示例：

#include <vector>
#include <iostream>

class Resource {
public:
    Resource(int total) : total_(total) {}

    int total; // 总资源量
};

class Process {
public:
    Process(int id, const std::vector<int>& maxDemands)
        : id_(id), maxDemands_(maxDemands), allocated_(maxDemands.size(), 0) {}

    int id; // 进程标识符
    std::vector<int> maxDemands_; // 最大需求
    std::vector<int> allocated_; // 已分配资源
};

class BankersAlgorithm {
private:
    std::vector<Resource> resources; // 资源向量
    std::vector<Process> processes; // 进程数组
    bool isSafeState = false; // 系统是否处于安全状态标志

public:
    BankersAlgorithm(const std::vector<int>& totalResources, const std::vector<Process>& initialProcesses)
        : resources(totalResources.size()), processes(initialProcesses) {
        // 初始化资源和进程
    }

    void requestResources(int processId, const std::vector<int>& request) {
        // 请求资源处理逻辑
    }

    void releaseResources(int processId, const std::vector<int>& release) {
        // 释放资源处理逻辑
    }

    void checkSafety() {
        // 安全性检查逻辑
    }
};

3.2.2 算法逻辑的封装与实现

在 BankersAlgorithm 类中，我们需要实现算法的核心逻辑。这包括资源请求处理和安全性检查。当一个进程请求资源时，算法需要确定是否可以满足其请求而不引发死锁。如果请求可以被满足，则更新资源状态；否则，进程将等待。安全性检查则用于确定系统是否能进入一个安全状态，即是否存在一种资源分配序列，使得每个进程都可以顺利完成而不发生死锁。

以下是资源请求处理逻辑的示例代码：

void BankersAlgorithm::requestResources(int processId, const std::vector<int>& request) {
    // 检查请求是否大于最大需求
    for (size_t i = 0; i < request.size(); ++i) {
        if (request[i] > processes[processId].maxDemands_[i]) {
            throw std::invalid_argument("Request exceeds the maximum demand.");
        }
    }

    // 尝试分配资源
    bool canAllocate = true;
    for (size_t i = 0; i < request.size() && canAllocate; ++i) {
        if (request[i] > resources[i].total - resources[i].allocated) {
            canAllocate = false; // 资源不足
        }
    }

    // 如果可以分配，则更新资源状态
    if (canAllocate) {
        for (size_t i = 0; i < request.size(); ++i) {
            resources[i].allocated += request[i];
            processes[processId].allocated_[i] += request[i];
        }

        // 调用安全性检查函数
        checkSafety();
    } else {
        // 处理资源不足的情况，进程等待
        std::cout << "Process " << processId << " is waiting." << std::endl;
    }
}

安全性检查逻辑的实现类似，涉及到对系统当前状态的分析，判断是否存在至少一个进程可以成功完成，从而释放资源，使得其他进程也能依次完成，直至所有进程都能顺利完成。

通过以上代码和逻辑的封装，我们可以用面向对象的方式管理银行家算法的复杂性，提高代码的可维护性和扩展性。在实际的应用中，还需要对算法进行测试和验证，确保其正确性。

4. 资源请求处理与安全性检查

4.1 初始化系统资源

4.1.1 资源数据的初始化方法

在银行家算法的C++实现中，资源数据的初始化是系统启动后首先进行的一个步骤。这是因为算法需要通过一系列的数据来模拟系统中可用资源与各进程间的关系。初始化通常包括以下几个方面：

1. 定义资源类型：明确系统中有哪几种资源，例如CPU、内存、磁盘等。
2. 创建资源向量：根据资源类型，创建资源向量，如 Available 、 Max 、 Allocation 和 Need 等。
3. 初始化资源数据：为上述向量赋予实际的值，这通常基于系统的真实配置与限制。

例如，以下是一个资源初始化的代码片段：

#include <iostream>
#include <vector>

using namespace std;

// 初始化资源向量
void initializeResources(vector<int>& available, vector<int>& max) {
    // 假设有3种资源类型
    available = {10, 5, 7}; // 可用资源
    max = {15, 10, 10};     // 最大需求
}

在此代码块中， initializeResources 函数接受两个 vector<int> 参数，分别表示 available （可利用资源）和 max （最大需求），这些向量会被初始化为系统资源的模拟数据。

4.1.2 系统状态的初始化设置

初始化系统状态是确保算法正确运行的重要步骤。除了资源数据的初始化之外，系统状态还应该包含：

1. 进程状态：当前所有进程的状态信息，包括它们是否在等待或已释放。
2. 分配矩阵：记录各进程已分配资源数量的矩阵。
3. 需求矩阵：记录各进程对资源的最大需求的矩阵。

通过以下代码片段展示如何初始化这些状态：

// 初始化系统状态
void initializeSystemState(vector<vector<int>>& allocation, vector<vector<int>>& need) {
    // 假设系统中有4个进程
    allocation = {{1, 0, 0}, {2, 1, 1}, {3, 0, 2}, {2, 2, 2}};
    need = {{10, 5, 3}, {12, 4, 2}, {7, 9, 5}, {6, 6, 2}};
}

在初始化代码中， initializeSystemState 函数接受两个 vector<vector<int>> 参数，分别表示 allocation （分配矩阵）和 need （需求矩阵），这些矩阵需要根据实际进程对资源的需求来设置。

4.2 资源请求的处理机制

4.2.1 请求验证与安全性检查

资源请求的处理是银行家算法中的关键环节。当进程请求资源时，系统必须先进行请求验证，随后执行安全性检查，以确保不会产生死锁。请求验证包括：

1. 检查请求资源是否超出进程的最大需求。
2. 确认系统当前是否有足够的资源满足请求。

接下来是安全性检查。安全性检查是基于当前资源分配情况，判断系统是否能按某种顺序来满足所有进程的最大需求，从而避免进入不安全状态（可能导致死锁的状态）。安全性算法的伪代码如下：

SafetyCheck() {
    Work = Available
    Finish = [false, false, ..., false] // 初始化所有进程的完成状态为false
    while (存在未完成且可满足需求的进程P) {
        Work = Work + Allocation[P]
        Finish[P] = true
    }
    if (所有进程的Finish值都是true) {
        系统处于安全状态
    } else {
        系统处于不安全状态
    }
}

安全性检查流程中， Work 变量代表系统中剩余可用资源，而 Finish 数组记录每个进程是否可以顺利完成。通过循环，算法模拟资源分配过程，并尝试找到一个安全序列。若成功找到，则说明系统处于安全状态；若失败，则表示系统可能进入死锁状态。

4.2.2 资源分配与进程等待

若请求通过验证并确定系统处于安全状态，则资源请求会被批准，相应资源会被分配给进程，进程将进入运行状态。若请求无法满足或系统处于不安全状态，则进程需等待，直到资源释放或其他进程完成。

4.3 安全性检查流程

4.3.1 安全性算法的逻辑流程

安全性检查是确保系统不进入死锁状态的核心算法。安全性算法流程具体步骤如下：

1. 从 Available 向量中复制一份数据到 Work 向量，表示系统当前可用于分配的资源。
2. 初始化 Finish 数组，所有进程都标记为 false ，表示没有进程完成。
3. 对于每一个未完成的进程，按 Need 矩阵进行判断，若 Work >= Need ，则认为该进程可以顺利完成。
4. 如果进程可以顺利完成，将分配给该进程的资源量加回 Work ，表示这部分资源重新变为可用。
5. 将该进程的 Finish 标记为 true ，表示完成。
6. 重复步骤3-5，直到所有进程的 Finish 都为 true ，或者找不到可以顺利完成的进程。

安全性算法用伪代码表示如下：

for each process P {
    if Finish[P] == false {
        if Need[P] <= Work {
            Work = Work + Allocation[P]
            Finish[P] = true
        }
    }
}

4.3.2 系统安全状态的判定

系统安全状态的判定是通过安全性算法来实现的，如果算法可以找到至少一种安全序列，表明系统是安全的。下面是判定过程的代码块：

bool isSafe(vector<int>& available, vector<vector<int>>& allocation, vector<vector<int>>& need) {
    int n = allocation.size(); // 进程数量
    vector<int> work(available); // 可用资源向量
    vector<bool> finish(n, false); // 进程完成向量

    while (true) {
        bool found = false;
        for (int i = 0; i < n; i++) {
            if (!finish[i]) {
                bool possible = true;
                for (int j = 0; j < n; j++) {
                    if (need[i][j] > work[j]) {
                        possible = false;
                        break;
                    }
                }
                if (possible) {
                    for (int k = 0; k < n; k++) {
                        work[k] += allocation[i][k];
                    }
                    finish[i] = true;
                    found = true;
                }
            }
        }
        if (!found) break; // 如果这一轮没有进程完成，则退出循环
    }

    for (bool f : finish) {
        if (!f) return false; // 若还有进程未完成，则返回false
    }
    return true; // 所有进程都可完成，返回true
}

在以上代码中， isSafe 函数判断是否系统处于安全状态，它使用 work 向量表示当前可用资源， finish 数组表示进程完成状态。通过循环迭代，逐一检查是否每个进程都能在不引起资源不足的情况下完成，如果可以，则返回 true 表示系统是安全的；反之，则返回 false 。

安全性检查的实现为银行家算法提供了预防死锁的关键步骤，确保系统资源管理的合理性。

5. 资源分配与释放操作

5.1 资源分配与释放的策略

5.1.1 确定性分配与非确定性分配

在操作系统中，资源分配是一个核心问题。确定性分配策略是基于先来先服务(FCFS)、最高优先级或最短处理时间优先等规则来进行资源分配。而非确定性分配策略通常依赖于启发式方法，例如银行家算法，来动态决定资源分配。确定性策略简单易于实现，但可能无法提供最优的资源使用效率。非确定性策略虽然复杂且开销较大，却能更有效地预防死锁和提升资源利用率。

在C++中，可以通过构造函数和析构函数实现资源的自动分配和释放，这样可以减少资源泄露的风险。例如，利用智能指针（如std::unique_ptr）可以确保资源在作用域结束时自动释放。

5.1.2 进程资源释放的时机与方式

正确的释放进程所占用的资源是非常重要的。一般而言，进程终止时会释放其占用的资源。在C++中，这通常是通过析构函数自动完成的。但是，如果资源分配策略中包括资源的预分配和延迟释放，就必须有一个清晰的机制来手动处理这些资源。

资源释放的策略应当遵循最小权限原则，即进程只在需要时获取资源，在不再需要时尽快释放。这可以通过使用RAII（资源获取即初始化）原则来实现，以确保资源的正确和及时释放。

5.2 VS2010环境下的程序开发

5.2.1 VS2010的项目设置和调试技巧

在Visual Studio 2010中，项目设置包括配置管理器、编译器选项、链接器设置等。为了优化程序性能，开发者可以调整编译器优化级别，例如选择 /O2 或 /Ox 以启用更高级别的优化。在调试时，可以使用断点、单步执行、监视表达式和内存窗口等调试技巧。

调试技巧的运用，特别是在处理资源分配相关的逻辑时，能够帮助开发者快速定位问题所在。例如，在资源分配失败时，程序可能抛出异常。在VS2010中，可以设置异常断点来捕获特定类型的异常。

5.2.2 代码优化与性能测试

代码优化是提高程序运行效率的重要步骤。可以针对特定的算法或数据结构进行优化。例如，在银行家算法实现中，矩阵的遍历和更新是关键性能点，应尽量减少循环次数和提高数据访问效率。

性能测试是评估代码优化效果的重要手段。在VS2010中，可以使用性能分析器工具来分析程序的CPU使用率、内存分配情况等。性能测试帮助开发者识别瓶颈，对程序进行针对性优化。

// 示例代码：银行家算法中的资源请求处理函数
bool requestResources(int processID, int *request) {
    // ... 省略部分代码，包括检查请求是否超过最大需求等逻辑 ...
    for (int i = 0; i < NumOfResources; i++) {
        if (request[i] > need[processID][i] || request[i] > available[i]) {
            return false; // 请求超出需求或可用资源
        }
    }

    for (int i = 0; i < NumOfResources; i++) {
        available[i] -= request[i];
        allocation[processID][i] += request[i];
        need[processID][i] -= request[i];
    }
    // 检查安全性
    if (checkSafety(need, allocation, available)) {
        return true;
    } else {
        // 如果不安全，回滚
        for (int i = 0; i < NumOfResources; i++) {
            available[i] += request[i];
            allocation[processID][i] -= request[i];
            need[processID][i] += request[i];
        }
        return false;
    }
}

在上述示例代码中， requestResources 函数处理一个进程的资源请求。它首先检查请求是否合理，然后更新资源分配表。如果更新后的状态不安全，它将回滚更改并返回错误。

5.3 用户界面设计与调试

5.3.1 界面布局与功能划分

良好的用户界面应该直观易用，功能明确。在设计时，要考虑到用户的操作习惯和使用场景。例如，对于资源分配和释放操作，可以提供一个简洁的表格界面来显示当前资源状态，以及“请求”和“释放”按钮来执行对应的操作。

界面元素应当按逻辑分组，如将资源分配操作集中在一侧，将资源释放操作集中在另一侧。在VS2010中，可以利用Windows Forms或WPF技术来构建用户界面，并通过拖放组件来实现布局。

5.3.2 用户交互流程与错误处理

用户交互流程应流畅，尽量减少用户的输入负担。例如，当用户请求资源时，可以从已有的历史记录中选择或输入值。错误处理是提高用户满意度的关键环节。需要为各种可能的错误情况提供清晰的提示和指导。

在VS2010中，可以使用try-catch块来捕获代码中可能发生的异常，并向用户提供错误信息。此外，还可以添加日志记录功能，记录操作历史和错误信息，便于问题的追踪和调试。

在本章中，我们详细讨论了资源分配与释放的策略、VS2010环境下的程序开发以及用户界面设计与调试。每个话题都深入浅出地介绍了其核心概念和实用技巧，为开发者在资源管理和用户交互设计方面提供了丰富的参考信息。

本文还有配套的精品资源，点击获取

简介：银行家算法是一种用于预防操作系统中死锁的策略，通过模拟银行贷款分配过程，确保系统资源分配的安全性。本文详细介绍了银行家算法的工作原理和C++程序实现，包括初始化系统资源、处理资源请求、进行安全性检查以及资源分配和释放的步骤。程序使用VS2010环境编写，重点在于数据结构设计、文件读取、安全性检查算法、用户界面和程序调试。通过银行家算法的编程实践，可以加深对死锁避免策略的理解。

本文还有配套的精品资源，点击获取