C++项目中打破循环依赖的锁链：实用方法大全（二）-阿里云开发者社区

C++项目中打破循环依赖的锁链：实用方法大全（一）https://developer.aliyun.com/article/1464092

3.2 移除中间人（Remove Middle Man）

移除中间人是一种代码重构技巧，旨在减少不必要的间接层次，简化代码结构。在解决循环依赖问题时，可以通过移除中间人来减少模块之间的依赖关系。

以下是移除中间人的关键步骤：

3.2.1 识别中间人（Identify Middle Man）

在重构过程中，识别中间人是移除中间人方法的关键步骤。中间人通常是一个类或模块，它的主要职责是将其他类或模块的方法和属性传递给调用者。以下是一些识别中间人的方法：

审查代码：通过阅读和审查代码，可以找出潜在的中间人。中间人通常具有以下特征：

仅包含少量代码，主要用于调用其他类或模块的方法。
缺乏自身的业务逻辑，主要依赖其他类或模块的功能。
与其他类或模块具有紧密的耦合关系。

分析依赖关系：创建项目的依赖关系图，以识别可能的中间人。中间人通常位于依赖链的中间位置，将其他类或模块的功能传递给调用者。分析依赖关系图可以帮助找到这样的中间人。
度量复杂性：度量代码复杂性可以帮助识别中间人。中间人通常具有较低的代码复杂性，因为它们主要负责将调用传递给其他类或模块。使用代码度量工具可以找到具有较低复杂性的潜在中间人。
团队讨论：与团队成员讨论项目结构和依赖关系可以帮助识别中间人。团队成员可能已经注意到某些类或模块在项目中的中间人角色，并可以提供宝贵的反馈。

通过以上方法，可以在项目中找到潜在的中间人。识别中间人后，可以开始重构调用者并移除不再需要的中间人，从而简化代码结构，减少循环依赖问题。

3.2.2 重构调用者（Refactor Caller）

在识别出中间人之后，下一步是重构调用者，使其直接访问被中间人封装的方法和属性。这可以通过以下步骤实现：

查找调用者：找出项目中所有调用中间人的地方。这些调用者依赖于中间人提供的方法和属性，并通过中间人间接地访问其他类或模块。
替换间接调用：修改调用者的代码，让它直接与被中间人封装的目标类或模块进行交互。这可能包括以下操作：

更新调用者的导入语句，使其直接导入目标类或模块。
替换调用者中的间接调用，直接使用目标类或模块的方法和属性。
如果需要，调整调用者的代码结构，以适应新的依赖关系。

验证调用者的功能：在重构调用者后，确保它仍然能正常工作。运行项目的测试用例，并手动测试调用者的功能，以验证重构没有引入新的错误或破坏现有功能。
重复以上步骤：如果项目中有多个调用者依赖于同一个中间人，重复以上步骤，直到所有调用者都不再依赖于中间人。

通过重构调用者，可以减少项目中不必要的间接层次，简化代码结构。在确保调用者可以正常工作的前提下，可以继续进行下一步，即移除中间人。

3.2.3 移除中间人（Remove Middle Man）

在重构调用者并确保其正常工作后，可以开始移除不再需要的中间人。以下是移除中间人的步骤：

删除中间人类或模块：在确保所有调用者都不再依赖于中间人的前提下，从项目中删除中间人类或模块。这可以通过直接删除源代码文件或从项目配置中移除相关条目来实现。
清理依赖关系：检查项目中的依赖关系，确保没有其他类或模块依赖于已删除的中间人。如果有其他类或模块仍然依赖于中间人，需要进行进一步的重构，直到中间人完全被移除。
更新文档和注释：移除中间人后，更新项目文档和代码注释，以反映代码结构的变化。确保其他开发者了解为什么中间人被移除，以及如何使用新的代码结构。
执行测试：在完成中间人的移除后，运行项目的测试用例，以确保移除过程没有引入新的错误或破坏现有功能。此外，对项目进行手动测试，以验证代码重构的结果。

通过以上步骤，可以成功移除项目中的中间人，从而简化代码结构并减少模块之间的依赖关系。这有助于解决循环依赖问题，同时提高代码的可维护性和可读性。然而，在移除中间人时，需要确保不会破坏现有功能或引入新的错误。在使用移除中间人方法时，务必谨慎，并根据项目的具体情况进行调整。

3.2.4 代码示例

在本示例中，我们将展示如何在C++项目中应用移除中间人方法。假设我们有以下三个类：Caller、MiddleMan 和 Target。

caller.h

#pragma once
#include "middle_man.h"
class Caller {
public:
    void doSomething();
private:
    MiddleMan middle_man;
};

caller.cpp

#include "caller.h"
void Caller::doSomething() {
    middle_man.performTask();
}

middle_man.h

#pragma once
#include "target.h"
class MiddleMan {
public:
    void performTask();
private:
    Target target;
};

middle_man.cpp

#include "middle_man.h"
void MiddleMan::performTask() {
    target.performTask();
}

target.h

#pragma once
class Target {
public:
    void performTask();
};

target.cpp

#include "target.h"
void Target::performTask() {
    // ...
}

在这个示例中，MiddleMan 类仅将 Target 类的 performTask 方法传递给 Caller 类，因此我们可以将其视为一个中间人。为了移除中间人，我们需要执行以下操作：

修改 Caller 类，使其直接依赖于 Target 类而非 MiddleMan 类。
更新 Caller 类的 doSomething 方法，以直接调用 Target 类的 performTask 方法。
删除 MiddleMan 类。

修改后的代码如下：

caller.h

#pragma once
#include "target.h"
class Caller {
public:
    void doSomething();
private:
    Target target;
};

caller.cpp

#include "caller.h"
void Caller::doSomething() {
    target.performTask();
}

target.h 和 target.cpp 保持不变。

在上述示例中，我们通过移除中间人方法成功简化了代码结构，并减少了模块之间的依赖关系。在应用移除中间人方法时，请确保不会破坏现有功能或引入新的错误，并根据项目的具体情况进行调整。

3.3 合并模块（Merge Modules）

合并模块是一种代码重构策略，可以将相关的类或模块合并到一个更大的模块中。这有助于简化项目结构，减少循环依赖问题的出现。

以下是合并模块的关键步骤：

3.3.1 识别相关模块（Identify Related Modules）

在合并模块的过程中，首先需要识别具有循环依赖关系的相关模块。这是一个关键步骤，因为只有找到紧密耦合的模块，才能进行有效的合并。以下是一些可以帮助识别相关模块的方法：

代码审查：通过对项目代码进行审查，可以找出紧密耦合的模块。这通常需要对代码具有深入的了解，以便找出具有相似功能或领域知识的模块。
依赖关系图：创建项目的依赖关系图可以帮助识别模块之间的关系。通过分析图形，可以找到具有循环依赖或紧密关联的模块。一些集成开发环境（IDE）和代码分析工具可以自动生成依赖关系图。
代码度量：通过度量代码的耦合性和内聚性，可以找出需要合并的模块。高度耦合的模块可能需要合并，而内聚性高的模块可能已经处于合适的分组。一些代码分析工具可以提供这些度量。
团队讨论：与团队成员讨论项目的模块划分可以帮助找到相关模块。其他团队成员可能已经意识到了一些模块之间的紧密关系，并可以提供宝贵的意见。

通过以上方法，可以找到项目中具有循环依赖关系和紧密耦合的相关模块。在识别相关模块后，才能进行下一步的合并模块分析和实际合并操作。

3.3.2 分析合并影响（Analyze Merge Impact）

在合并模块之前，需要分析合并操作对项目的潜在影响。这是一个重要的步骤，因为合并模块可能会导致代码的重复或耦合度增加，从而影响项目的可维护性和可扩展性。以下是分析合并影响的一些建议：

识别重复代码：在合并模块时，可能会出现重复代码。识别这些重复代码并确保在合并过程中进行适当的重构，以消除不必要的冗余。
评估耦合度和内聚性：分析合并后的模块是否会导致耦合度过高或内聚性降低。如果合并会导致这些问题，可能需要重新考虑合并策略或寻求其他解决方案。
检查接口和API的影响：合并模块可能会影响项目的接口和API。确保合并后的模块能够保持原有的功能，并对外提供一致的接口。
测试影响：评估合并模块对现有测试用例和测试覆盖率的影响。确保合并后的模块能够通过现有测试，以保持项目的稳定性。
性能影响：分析合并模块对项目性能的影响。如果合并后的模块导致性能下降，可能需要重新评估合并策略或优化代码。

通过对合并影响进行分析，可以确保合并模块对项目的负面影响最小化。在确认合并不会对项目造成负面影响的前提下，才进行实际的合并操作。

3.3.3 合并模块（Merge Modules）

在完成识别相关模块和分析合并影响的步骤后，可以开始实际合并模块。这个过程涉及将相关模块的类或函数移动到新的、更大的模块中，并修改相应的依赖关系。以下是合并模块的一些建议：

创建新模块：为合并后的模块创建一个新的、描述性强的名称。确保新模块的名称可以清晰地表达其职责和功能。
移动类和函数：将相关模块中的类和函数移动到新创建的模块中。在移动过程中，确保保留原有的代码结构和逻辑。
修改依赖关系：在将类和函数移动到新模块后，需要更新项目中的依赖关系。这包括修改导入语句、调整类和函数的访问权限等。
重构和优化：在合并模块的过程中，可能需要进行一些重构和优化操作，以消除重复代码、降低耦合度和提高内聚性。这可能包括合并重复的方法、提取公共功能等。
更新文档和注释：在合并模块后，更新项目文档和代码注释，以反映模块合并后的新结构。
执行测试：在完成合并操作后，运行项目的测试用例，以确保合并过程没有引入新的错误或破坏现有功能。

通过以上步骤，可以将相关模块合并为一个更大的模块，从而简化项目结构并减少循环依赖问题。然而，需要注意的是，过度合并模块可能导致代码过于耦合，降低可维护性。因此，在使用合并模块方法时，需要权衡利弊并根据具体情况进行调整。

3.3.4 代码示例

在这个示例中，我们将展示如何将两个紧密耦合的C++模块（module_a.h、module_a.cpp、module_b.h 和 module_b.cpp）合并为一个更大的模块（merged_module.h 和 merged_module.cpp）。

假设我们有以下两个模块：

module_a.h

#pragma once
#include "module_b.h"
class ModuleA {
public:
    void doSomethingA();
    void doSomethingWithB();
private:
    ModuleB b_instance;
};

module_a.cpp

#include "module_a.h"
void ModuleA::doSomethingA() {
    // ...
}
void ModuleA::doSomethingWithB() {
    b_instance.doSomethingB();
}

module_b.h

#pragma once
class ModuleB {
public:
    void doSomethingB();
};

module_b.cpp

#include "module_b.h"
void ModuleB::doSomethingB() {
    // ...
}

现在，我们将这两个模块合并为一个更大的模块。

merged_module.h

#pragma once
class MergedModuleA {
public:
    void doSomethingA();
    void doSomethingWithB();
private:
    class MergedModuleB {
    public:
        void doSomethingB();
    };
    
    MergedModuleB b_instance;
};

merged_module.cpp

#include "merged_module.h"
void MergedModuleA::doSomethingA() {
    // ...
}
void MergedModuleA::doSomethingWithB() {
    b_instance.doSomethingB();
}
void MergedModuleA::MergedModuleB::doSomethingB() {
    // ...
}

在上述示例中，我们将原来的两个模块合并为一个更大的模块。在这个过程中，我们将 ModuleB 类移动到 MergedModuleA 类中，并将其声明为一个私有内部类。同时，我们还需要更新实现文件，将 ModuleB 的实现移动到 merged_module.cpp 文件中。

这样，我们就将两个紧密耦合的模块合并为一个更大的模块，从而简化项目结构并减少循环依赖问题。然而，请注意，过度合并可能导致代码过于耦合，降低可维护性。在使用合并模块方法时，需要权衡利弊并根据具体情况进行调整。

四、工具与技巧（Tools and Techniques）

在解决C++项目中的循环依赖问题时，可以使用一些工具和技巧来辅助分析和诊断。这些工具和技巧有助于识别项目中存在的循环依赖，从而采取相应的解决措施。

4.1 静态代码分析工具（Static Code Analysis Tools）

静态代码分析工具可以在编译时检查项目中的代码，以识别潜在的循环依赖问题。这些工具可以帮助开发者在项目的早期阶段发现循环依赖，从而避免问题的恶化。

以下是一些常用的静态代码分析工具：

4.1.1 Cppcheck

Cppcheck是一个C++代码静态分析工具，可以检查潜在的循环依赖问题。Cppcheck具有跨平台支持，可以在Windows、Linux和macOS上运行。

4.1.2 Clang-Tidy

Clang-Tidy是一个基于Clang编译器的C++代码静态分析工具。它提供了一系列检查器，可以识别循环依赖等多种潜在问题。

4.1.3 PVS-Studio

PVS-Studio是一个用于C、C++和C#的静态代码分析工具。它可以检查项目中的循环依赖问题，并提供详细的错误报告和修复建议。

通过使用静态代码分析工具，开发者可以及时发现循环依赖问题，从而采取相应的解决措施。这有助于提高项目的代码质量和可维护性。

4.2 依赖关系图（Dependency Graph）

依赖关系图是一种可视化工具，用于展示项目中模块之间的依赖关系。通过分析依赖关系图，开发者可以识别项目中存在的循环依赖，从而采取相应的解决措施。

以下是使用依赖关系图的关键步骤：

4.2.1 生成依赖关系图（Generate Dependency Graph）

首先，使用专门的工具或脚本生成项目的依赖关系图。这些工具通常可以分析项目中的源代码文件和头文件，以确定模块之间的依赖关系。一些常用的依赖关系图生成工具包括Doxygen、Graphviz和CMake。

4.2.2 分析依赖关系（Analyze Dependencies）

然后，分析生成的依赖关系图，以识别项目中存在的循环依赖。循环依赖通常表现为依赖关系图中的闭环，可以通过手动检查或使用自动分析工具进行识别。

4.2.3 优化依赖关系（Optimize Dependencies）

最后，在识别并解决项目中的循环依赖后，可以进一步优化依赖关系。这可能包括重新组织模块、减少不必要的依赖或应用其他代码重构技巧。优化依赖关系有助于提高项目的可维护性和可扩展性。

通过使用依赖关系图，开发者可以直观地了解项目中模块之间的依赖关系，并及时发现并解决循环依赖问题。这有助于保持项目的健康状态，降低潜在的维护成本。

4.3 单元测试与集成测试（Unit Testing and Integration Testing）

单元测试和集成测试是软件开发过程中的重要组成部分，它们可以帮助开发者确保项目中的各个模块正常运行并与其他模块协同工作。通过编写和执行单元测试和集成测试，开发者可以发现和解决循环依赖问题，从而提高项目的稳定性和可维护性。

以下是使用单元测试和集成测试的关键步骤：

4.3.1 编写单元测试（Write Unit Tests）

首先，为项目中的每个模块编写单元测试。单元测试应该针对模块的各个功能进行测试，以确保它们按预期运行。在编写单元测试时，开发者应该尽量减少模块之间的依赖，从而降低循环依赖的风险。

4.3.2 编写集成测试（Write Integration Tests）

然后，编写集成测试以验证项目中的各个模块如何协同工作。集成测试应该模拟真实的使用场景，并检查模块之间的交互是否正常。通过执行集成测试，开发者可以发现并解决项目中存在的循环依赖问题。

4.3.3 持续集成与持续测试（Continuous Integration and Continuous Testing）

最后，将单元测试和集成测试集成到项目的持续集成（CI）流程中。这样，每次提交代码更改时，CI系统都会自动执行测试，以确保项目始终处于稳定状态。持续集成与持续测试有助于及时发现和解决循环依赖问题，从而提高项目的质量和可靠性。

通过使用单元测试和集成测试，开发者可以确保项目中的各个模块正常运行并与其他模块协同工作。这有助于发现和解决循环依赖问题，提高项目的稳定性和可维护性。

C++项目中打破循环依赖的锁链：实用方法大全（三）https://developer.aliyun.com/article/1464102

C++项目中打破循环依赖的锁链：实用方法大全（二）