AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

设计模式总结（一）

2024-01-10 47
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 设计模式总结（一）

面对对象中有哪些设计原则

开闭原则

里氏替换原则

迪米特原则

依赖导致原则


** 举例解释**

自动驾驶系统公司是高层，汽车生产厂商为低层，它们不应该互相依赖，一方变动另一方也会跟着变动；而应该抽象一个自动驾驶行业标准，高层和低层都依赖它；这样以来就解耦了两方的变动；自动驾驶系统、汽车生产厂商都是具体实现，它们应该都依赖自动驾驶行业标准（抽象）。

多线程环境下单例模式

单例单线程模式

  • 保证一个类仅有一个实例：使用静态成员变量形式来实现。
  • 提供该实例的全局访问点：使用静态的成员函数来实现。
  • 保证申请在堆区的Singleton()能够被释合理的释放掉：使用c++中的库函数atextit()，atexit函数详解参考。并需手动实现析构函数。
  • 为了实现只能通过GetInstance()函数来实现对象的创建需要对外屏蔽构造函数、赋值操作、拷贝构造函数。
  • 静态成员函数只能访问静态成员变量和静态成员函数。
  • 静态成员函数没有this指针，不能调用成员函数，可参考static、const关键字。
//Singleton
#include <iostream>
class Singleton {
public:
  static Singleton* GetInstance() {
    if (_instance == nullptr) {
      _instance = new Singleton();
      std::atexit(Destructor);  //登记函数  
    }
    return _instance;
  }
private:
  static void Destructor() {  //实现析构
    if (_instance != nullptr) {
      delete _instance;
      _instance = nullptr;
    }
  }
  Singleton() {};
  ~Singleton() {};  
  Singleton(const Singleton &clone) {};  //拷贝构造函数
  Singleton &operator= (const Singleton &) {};  //赋值操作
  static Singleton *_instance;  //一个类只有一个实例
};
Singleton* Singleton::_instance = nullptr;  //静态变量，类内声明类外初始化

多线程环境下单例模式—只加锁

  • 加锁只保证了临界资源只有一个线程访问。
//Singleton_thread 加锁
#include <iostream>
#include <mutex>
class Singleton {
public:
  static Singleton* GetInstance() {
    //std::lock_guard<std::mutex> lock(_mutex);  //该位置锁的力度过大
    if (_instance == nullptr) {  //第一次_instance没有值
      std::lock_guard<std::mutex> lock(_mutex);
      if (_instance == nullptr) {  //其他情况下_instance有值
        _instance = new Singleton();  //多线程环境下编译器和CPU会对程序进行优化
        std::atexit(Destructor);
      } 
    }
    return _instance;
  }
private:
  static void Destructor() {  //实现析构
    if (_instance != nullptr) {
      delete _instance;
      _instance = nullptr;
    }
  }
  Singleton() {};
  ~Singleton() {};  
  Singleton(const Singleton &clone) {};  //拷贝构造函数
  Singleton &operator= (const Singleton &) {};  //赋值操作
  static Singleton *_instance;
  static std::mutex _mutex;
};
Singleton* Singleton::_instance = nullptr;  //静态变量，类内声明类外初始化
std::mutex Singleton::_mutex;

多线程环境下单例模式—加锁+原子操作

  • 多线程环境下编译器会对程序进行优化，导致指令执行顺序发生变化。
  • new 操作符执行了哪些操作：
    1） 分配内存；
    2）调用构造函数 （比较耗时）；

3）返回指针，赋值运算符。

编译器优化后执行顺序可能为：1 3 2。就会出现内存还没有进行构造就进行了返回。即_instance 不为空，但是_instaned没有经过构造函数初始化其内存，当使用到的时候就会出现错误。利用原子变量来避免这个现象。

//Singleton_atomic
#include <iostream>
#include <mutex>
#include <atomic>
class Singleton {
public:
  static Singleton* GetInstance() {
    Singleton* tmp = _instance.load(std::memory_order_relaxed);  //保证tmp原子性
    std::atomic_thread_fence(std::memory_order_acquire);  //内存屏障，不让tmp优化到下面
    //std::lock_guard<std::mutex> lock(_mutex);  //该位置锁的力度过大
    if (tmp == nullptr) {  //第一次_instance没有值
      std::lock_guard<std::mutex> lock(_mutex);
      tmp = _instance.load(std::memory_order_relaxed);
      if (tmp == nullptr) {  //其他情况下_instance有值
        tmp = new Singleton();  //多线程环境下编译器和CPU会对程序进行优化
        std::atomic_thread_fence(std::memory_order_release);  //不让store优化到上面去
        _instance.store(tmp, std::memory_order_relaxed);  //将tmp写回原子变量_instance中
        std::atexit(Destructor);
      } 
    }
    return tmp;
  }
private:
  static void Destructor() {  //实现析构
    Singleton* tmp = _instance.load(std::memory_order_relaxed);
    if (tmp != nullptr) {
      delete _instance;
      tmp = nullptr;
      _instance.store(tmp, std::memory_order_relaxed);
    }
  }
  Singleton() {};
  ~Singleton() {};  
  Singleton(const Singleton &clone) {};  //拷贝构造函数
  Singleton &operator= (const Singleton &) {};  //赋值操作
  static std::atomic<Singleton*> _instance;
  static std::mutex _mutex;
};
std::atomic<Singleton*> Singleton::_instance;  //静态变量，类内声明类外初始化
std::mutex Singleton::_mutex;

工厂模式

工厂模式

// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv

//factory
#include <string>
// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
class IExport {
public:
    virtual bool Export(const std::string &data) = 0;
    virtual ~IExport(){}
};
class ExportXml : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class ExportJson : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class ExportTxt : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class ExportCSV : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class IExportFactory {
public:
    IExportFactory() {
        _export = nullptr;
    }
    virtual ~IExportFactory() {
        if (_export) {
            delete _export;
            _export = nullptr;
        }
    }
    bool Export(const std::string &data) {
        if (_export == nullptr) {
            _export = NewExport();
        }
        return _export->Export(data);
    }
protected:
    virtual IExport * NewExport(/* ... */) = 0;
private:
    IExport* _export;
};
class ExportXmlFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportXml();
        // 可能之后有什么操作
        return temp;
    }
};
class ExportJsonFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportJson;
        // 可能之后有什么操作
        return temp;
    }
};
class ExportTxtFactory : public IExportFactory {
protected:
    IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportTxt;
        // 可能之后有什么操作
        return temp;
    }
};
class ExportCSVFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportCSV;
        // 可能之后有什么操作
        return temp;
    }
};
int main () {
    IExportFactory *factory = new ExportTxtFactory();
    factory->Export("hello world");
    return 0;
}

抽象工厂

导出功能（IExport ）、导入功能（IImport），同一个格式的导入和导出是相关联的，我们通过一个接口去封装这个关联性，这里用IDataApiFactory来实现。

#include <string>
// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
class IExport {
public:
    virtual bool Export(const std::string &data) = 0;
    virtual ~IExport(){}
};
class ExportXml : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class ExportJson : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class ExportTxt : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class ExportCSV : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};
class IImport {
public:
    virtual bool Import(const std::string &data) = 0;
    virtual ~IImport(){}
};
class ImportXml : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};
class ImportJson : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};
class ImportTxt : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};
class ImportCSV : public IImport {
public:
    virtual bool Import(const std::string &data) {
        // ....
        return true;
    }
};
class IDataApiFactory {
public:
    IDataApiFactory() {
        _export = nullptr;
        _import = nullptr;
    }
    virtual ~IDataApiFactory() {
        if (_export) {
            delete _export;
            _export = nullptr;
        }
        if (_import) {
            delete _import;
            _import = nullptr;
        }
    }
    bool Export(const std::string &data) {
        if (_export == nullptr) {
            _export = NewExport();
        }
        return _export->Export(data);
    }
    bool Import(const std::string &data) {
        if (_import == nullptr) {
            _import = NewImport();
        }
        return _import->Import(data);
    }
protected:
    virtual IExport * NewExport(/* ... */) = 0;
    virtual IImport * NewImport(/* ... */) = 0;
private:
    IExport *_export;
    IImport *_import;
};
class XmlApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportXml;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportXml;
        // 可能之后有什么操作
        return temp;
    }
};
class JsonApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportJson;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportJson;
        // 可能之后有什么操作
        return temp;
    }
};
class TxtApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportTxt;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportTxt;
        // 可能之后有什么操作
        return temp;
    }
};
class CSVApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportCSV;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportCSV;
        // 可能之后有什么操作
        return temp;
    }
};
int main () {
    IDataApiFactory *factory = new CSVApiFactory();
    factory->Import("hello world");
    factory->Export("hello world");
    return 0;
}

直通通道：设计模式总结（二）

充电站

推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习


文章标签：
设计模式
自动驾驶
NoSQL
数据格式
编译器
想当开心果哦
目录
相关文章
yangnk42
|
设计模式 缓存 Java
设计模式
本文主要介绍设计模式的主要设计原则和常用设计模式。
yangnk42
126 0
设计模式
爱敲代码的小黄
|
7月前
|
设计模式 Java C#
C#设计模式——上
C#设计模式——上
爱敲代码的小黄
45 0
程序员三木
|
7月前
|
设计模式 存储 安全
[设计模式] 常见的设计模式
[设计模式] 常见的设计模式
程序员三木
61 0
清雨小竹
|
设计模式 安全
设计模式介绍
设计模式介绍
清雨小竹
51 0
念君思宁
|
设计模式 安全 Java
设计模式之单列模式
设计模式之单列模式
念君思宁
68 0
王群.wq
|
设计模式 存储 NoSQL
为什么我们需要设计模式？
设计模式解决什么问题设计模式一直被认为是一门难以学习的课程。究其原因是因为我们不清楚设计模式在解决哪些问题方面发挥作用。简言之，设计是为了实现特定的目标，基于不断更新的局部知识来获得解决方案的过程。我们通常熟悉的范式是在几乎掌握所有知识的情况下解决问题，例如解数学题、物理题等。然而，在软件编程过程中，我们掌握的知识往往不充分，而且会不断更新，因此需要我们关注有哪些知识，没有哪些知识，可以获取哪些知
王群.wq
9338 1
yanyingbai
|
设计模式 算法 Java
设计模式总结
设计模式总结
yanyingbai
81 0
小小工匠
|
设计模式 Java
23种设计模式
23种设计模式
小小工匠
145 0
Cool架构
|
设计模式 XML 存储
设计模式（七）
设计模式
Cool架构
98 0
龙哥手记
|
设计模式 存储 缓存
设计模式的几个问题
《基础系列》
龙哥手记
117 0

热门文章

最新文章

  • 1
    四大触点，教你从“用户视角”构建数据分析体系
  • 2
    Spring-boot+Dubbo应用启停源码分析
  • 3
    《Stata统计分析与应用（第2版）》一3.4 图形的保存、合并及修改
  • 4
    RocketMq-Request-Reply消息
  • 5
    Confluence 6 手动添加用户
  • 6
    2013年4月20日 通用权限管理系统组件V3.8功能改进说明
  • 7
    Configuring EIGRP Unequal-Cost Paths
  • 8
    PowerShell 指定关键词遍历文件内容
  • 9
    Windows时间服务出现故障 向用户发送错误的时间
  • 10
    三种dedecms调用相关文章的方法
  • 1
    《鸿蒙HarmonyOS应用开发从入门到精通（第2版）》简介
    39
  • 2
    《Python 助力：人工智能模型的“瘦身”与“加速”之旅》
    102
  • 3
    《非计算机专业者：Python 开启人工智能职业新航道》
    29
  • 4
    《Python赋能：智绘智慧城市新蓝图》
    34
  • 5
    《智育新篇：点亮学生人工智能伦理与社会责任之光》
    38
  • 6
    《数据主权：人工智能时代的核心基石与挑战》
    26
  • 7
    鸿蒙HarmonyOS应用开发 | 探索 HarmonyOS Next-从开发到实战掌握 HarmonyOS Next 的分布式能力
    102
  • 8
    鸿蒙原生开发环境的创新与性能优化：从工具到跨平台支持的全方位提升
    254
  • 9
    鸿蒙HarmonyOS应用开发 | 「鸿蒙技术分享」HarmonyOS NEXT元服务卡片实战体验
    150
  • 10
    Qwen-Coder：通过Qwen 2.5模型实现智能代码生成的技术实践
    33

    • 相关课程

    更多
  • 5天玩转Java面向对象编程
  • Java面向对象编程

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    DataWorks