^-^
游戏后端技术_设计模式
最近更新：2024-09-23   |   字数总计：2k   |   阅读估时：8分钟   |   阅读量：次
  1. 多线程环境下的单例模式
  2. 工厂模式以及抽象工厂
  3. 模板方法
  4. 访问者模式
  5. 责任链模式

多线程环境下的单例模式

  • 定义
    1. 一个类仅有一个实例
    2. 提供该实例的全局访问点
  • 现场手写单例模式
    • 基础功能：
      1. 静态成员函数和静态成员变量
      2. 构造、析构、拷贝构造和赋值运算符都私有化
      3. new是堆上创建的，所以使用atexit来释放
    • 多线程
      1. 两次判断，希望在第二次判断的时候加互斥锁
      2. 多线程环境下，编译器和cpu的优化（指令重排）
        • 原子操作加上内存屏障
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
// 第一版，堆区资源不能自动释放
class Singleton{
private:
    static Singleton *_instance;
    Singleton(){}
    ~Singleton(){}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton *GetInstance()
    {
        if(_instance == nullptr){
            _instance = new Singleton(); // 这个没有delete
        }
        return _instance;
    }
};
Singleton * Singleton::_instance = nullptr; 

// 第二版，仅实现了单线程完备
class Singleton{
private:
    static Singleton *_instance;
    Singleton(){}
    ~Singleton(){}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static void Destructor(){
        if(_instance != nullptr){
            delete _instance;
            _instance = nullptr;
        }
    }
public:
    static Singleton *GetInstance()
    {
        if(_instance == nullptr){
            _instance = new Singleton(); 
            std::atexit(Destructor); // 系统退出时调用
        }
        return _instance;
    }
};
Singleton * Singleton::_instance = nullptr; 

// 第三版，在cpu重排的环境下仍然有问题
#include <mutex>
class Singleton{
private:
    static Singleton *_instance;
    Singleton(){}
    ~Singleton(){}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static void Destructor(){
        if(_instance != nullptr){
            delete _instance;
            _instance = nullptr;
        }
    }
    static std::mutex _mutex;
public:
    static Singleton *GetInstance()
    {
        // std::lock_guard<std::mutex> lock(_mutex); // 这里加锁力度太大了，因为大多数情况下，都是有值的情况
        if(_instance == nullptr){
            std::lock_guard<std::mutex> lock(_mutex);
            if(_instance == nullptr){ // 防止另外一个线程也进入这个位置后多次构造，所以做双重判断
                /*
                    主要问题在这句，new 操作符所做的事情：
                    1. 分配内存
                    2. 调用构造函数
                    3. 返回指针，赋值运算
                    以上操作，2最耗时，所以优化结果可能是1，3，2，该情况下，其他线程可能得到了未调用构造函数（初始化）的一块不为nullptr的内存区域
                */
                _instance = new Singleton(); 
                std::atexit(Destructor); 
            }
        }
        return _instance;
    }
};
Singleton * Singleton::_instance = nullptr; 
std::mutex Singleton::_mutex;

// 第四版，多线程完备的，就是挺麻烦的
#include <mutex>
#include <atomic>
class Singleton{
private:
    static std::atomic<Singleton*> _instance;
    Singleton(){}
    ~Singleton(){}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static void Destructor(){
         Singleton *temp = _instance.load(std::memory_order_relaxed);
        if(temp != nullptr){
            delete temp;
            temp = nullptr;
            _instance.store(temp, std::memory_order_relaxed);
        }
    }
    static std::mutex _mutex;
public:
    static Singleton *GetInstance()
    {
        Singleton *temp = _instance.load(std::memory_order_relaxed);
        std::atomic_thread_funce(std::memory_order_acquire); // 读操作的内存屏障，保证前面的代码不会优化到后面去
        if(temp == nullptr){
            std::lock_guard<std::mutex> lock(_mutex);
            temp = _instance.load(std::memory_order_relaxed);
            if(temp == nullptr){ 
                temp = new Singleton(); 
                std::atomic_thread_funce(std::memory_order_release); // 写操作的内存屏障，保证后面的代码不会优化到前面去
                _instance.store(temp, std::memory_order_relaxed);
                std::atexit(Destructor); 
            }
        }
        return temp;
    }
};
std::atomic<Singleton*> Singleton::_instance; 
std::mutex Singleton::_mutex;

工厂模式以及抽象工厂

  • 什么是工厂模式？（需要答出以下几点）

    1. 定义：一个用于创建对象的接口，让子类决定实例化哪一个类
    2. 本质：延迟到子类阶段来选择实现该对象
    3. 符合的设计原则：
      1. 依赖倒置
      2. 面向接口
    4. 使用场景：解决创建过程比较复杂，目的是希望对外隐藏这些细节
      • 举例：
        1. 连接池、线程池
        2. 多个参数来决定创建
        3. 创建对象有复杂的依赖关系
    5. 实现（只说关键点）：
      1. 接口
      2. 子类继承接口，实现

  • 什么是抽象工厂？

    1. 定义：提供一个结构，让该接口创建一系列相关或者相互依赖的对象，无需指定他们的具体的类
    2. 场景：除了上述，相关性或者依赖性的多个对象

模板方法

  • 定义：定义一个操作中的算法骨架，将算法骨架中的步骤延迟到子类中去扩展。
  • 目的：可以使子类不改变算法的结构，通过子类扩展的方式定义定义该算法的某些步骤。
  • 应用场景：
    1. 有一个算法骨架
    2. 修改算法骨架中的流程
  • 构成：
    1. 算法骨架（可以被用户直接调用）（修改关闭）
    2. 用protected限定，将子流程通过虚函数化，子类可以复写子流程（扩展开放）
  • 符合哪些设计原则
    1. 单一职责原则
    2. 开闭原则
  • 跟其他设计模式的关系

访问者模式

  • 定义：访问者模式表示一个作用于某对象结构中各元素的操作，它使我们可以在不改变各元素的类的前提下，定义作用于这些元素的新操作；
    • 稳定点：对象结构中的元素，元素可以是多种，元素种类是稳定的
    • 变化点：对对象结构中元素的操作是变化点
  • 场景：
    • 需要解除数据结构和对数据结构的操作的耦合
    • 目的：将对数据结构的操作分离出来
  • 构成
    1. 对象结构类：管理各个稳定的元素
    2. 元素类
      • 元素基类：accept接口，参数是访问者的对象或指针
      • 具体元素类：在accept接口中调用参数传递过来的访问者
    3. 访问者类（元素操作类）
      • 访问者基类：Visit接口，有多少种元素，需要实现多少个Visit接口
        1. 函数重载，不同类型参数来实现
        2. 根据不同类型参数，设置不同函数名
      • 访问者实现类：要实现上门Visit接口，定义对元素的操作
  • 缺点：
    1. 元素种类是稳定点
    2. 所以不能够增加元素的种类
    3. 总之，需要比较稳定的数据结构，以及需求时针对数据结构变化的算法，这种情况下适合使用访问者模式
  • TC中的应用
    1. 对象结构类 Map->Cell->worldobject容器,gridobject容器
    2. 元素类：worldobject、gridobject
    3. 访问者类：
  • 案例：https://github.com/tristanpenman/visitor-pattern
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    class Shape
    {
    public:
        virtual ~Shape() = default;
        float getX() const;
        float getY() const;
        virtual void accept(ShapeVisitor &) = 0;    // Visitor pattern at work
    protected:
        Shape(float x, float y);
    private:
        ...
    };

    class Square : public Shape
    {
    public:
        Square(float x, float y, float width, float height);
        float getArea() const;
        float getHeight() const;
        float getWidth() const; 
        void accept(ShapeVisitor & visitor) override
        {
            visitor.visitShape(*this);
        }
    private:
        ...
    };

    class Circle : public Shape
    {
    public:
        Circle(float x, float y, float radius);
        float getArea() const;
        float getRadius() const;
        void accept(ShapeVisitor & visitor) override
        {
            visitor.visitShape(*this);
        }
    private:
        ...
    };

    class ShapeVisitor
    {
    public:
        virtual ~ShapeVisitor() = default;
        virtual void visitShape(const Circle &) = 0; // 使用元素种类区别操作 
        virtual void visitShape(const Square &) = 0;
        /*
            也可以使用名称来区别操作
            virtual void visitCircle(std::share_ptr<Shape >) = 0;
            virtual void visitSquare(std::share_ptr<Shape >) = 0;
        */
    };

    void BoundingBoxCalculator::visitShape(const Circle & circle)
    {
        const float x = circle.getX();
        const float y = circle.getY();
        const float radius = circle.getRadius();

        bottom = std::max(bottom, y + radius);
        left = std::min(left, x - radius);
        right = std::max(right, x + radius);
        top = std::min(top, y - radius);
    }
    void ShapePrinter::visitShape(const Square & square)
    {
        std::cout << "Square "
            << "{ x: " << square.getX()
            << ", y: " << square.getY()
            << ", width: " << square.getWidth()
            << ", height: " << square.getHeight()
            << " } " << std::endl;
    }

    int main()
    {
        std::vector<std::shared_ptr<Shape>> shapes;
        shapes.push_back(std::make_shared<Circle>(-1.f, 2.f, 0.5f));
        shapes.push_back(std::make_shared<Square>(12.f, 3.f, 1.2f, 3.4f));

        BoundingBoxCalculator calculator;
        for (auto shape : shapes) {
            shape->accept(calculator);
        }
    }

责任链模式

  • 定义：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，接受者是由多个处理对象构成，把这些处理对象连成一个链表，并沿着这个链条传递请求，直到由一个对象处理它为止。
  • 本质：分离职责，动态组合
  • 重点：
    1. 组合处理对象
    2. 链表关系
    3. 打断功能
  • 实现：
    1. 抽象接口，抽象传递流程
    2. 提供组合基类指针，实现处理链条
    3. 处理对象继承抽象接口
    4. 构建链条
  • 场景：
    1. 一个请求的处理，由多个步骤完成，这些步骤是有序的，这些步骤是可以自由组合的（如，处理一个http请求）
  • 符合哪些设计原则？
    1. 面向接口编程
    2. 组合优于继承
2024-07-13 该篇文章被 Cleofwine 归为分类: Game

上一篇：后端技术_无锁消息队列实现RingBuffer 下一篇：游戏后端技术_C++11
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题