七种常用设计模式----单例模式（三）

深藏阁楼爱情的钟 2023-09-27 14:35 113阅读 0赞

**目录**

01单例模式的实现方式

02单例模式在配置管理中的应用

03单例模式在IO操作的应用

04单例模式在前端交互的应用

--------------------

> **常用的七种设计模式:***单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式和责任链模式。*

想要写好代码，设计模式（Design Pattern）是必不可少的基本功，设计模式是对面向对象设计（Object Oriented Design）中反复出现的问题的解决方案，本篇从最简单的单例模式（Singleton Pattern）开讲。

单例模式属于创建型模式（Builder Pattern），意图在于保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式在内存中仅创建一次对象，即使多次实例化该类，也只返回第一次实例化后的实例对象，不仅能减少不必要的内存开销，并且在减少全局的函数和变量也具有重要的意义。

实现方式上，主要有懒汉式（Lazy Singleton）、饿汉式（Eager Singleton），多线程场景下需要注意线程安全。

场景上，最常用于全局配置管理，其次在IO操作、前端交互等需要保证对象唯一的场景，也可以使用。

![8db3f7b4a18f994c7e1259fb3a8bb90e.png][]

### **01单例模式的实现方式** ###

在golang中单例模式的实现方式有多种，这里介绍下使用init和sync.Once方式实现线程安全的单例。

其中init函数是在文件包首次被加载的时候执行并且只执行一次（Eager Singleton，饿汉模式），sync.Once是在代码运行需要的时候执行且只执行一次（Lazy Singleton，懒汉模式）。init函数方式直接创建好对象，不需要判断对象是否为空并持续占有在内存中，sync.Once是Go语言实现的一种对象，其相对高效且并发安全的实现原理主要是依赖于sync/atomic包的原子操作，在sync.Once的底层实现中，使用一个变量done来记录函数的执行状态，使用sync.Mutex和sync.atomic来保证线程安全的读取done，以保证某种行为只会被执行一次。需要注意的是once.Do(f func()) 方法不能嵌套，若f在执行过程中也会调用once.Do，会导致死锁。

在golang一些server业务场景应用中，通常会用到一些resource，如常用的：DB、Redis、Logger等，这些资源的实例化对象会在每个请求中频繁的使用，如果在每个请求的处理进程中频繁创建和释放这些资源对象，则会造成较大的系统资源开销，但如果使用单例的方式创建这些资源对象则能避免这些问题，通常实际使用场景中会在main主进程中的HTTPServer携程启动前，通过init或sync.One的方式创建单例对象提供各HTTPServer携程使用，从而保证各个请求处理进程中使用同一个实例对象。

......
    var (
      oResource sync.Once
    
      initFuncList = []initFunc{
        mustInitLoggers,  // 初始化Log
        mustInitServicer, // 初始化servicer以及ral
        mustInitGorm,     // 初始化mysql gorm
        mustInitRedis,    // 初始化redis
        mustInitOther,    // 初始化other
      }
    )
    
    type initFunc func(context.Context) func() error
    
    // MustInit 按顺序初始化app所需的各种资源
    func MustInit(ctx context.Context) (f func() error) {
      oResource.Do(func() {
        callbackList := make([]func() error, 0, len(initFuncList))
        for _, f := range initFuncList {
          callbackList = append(callbackList, f(ctx))
        }
    
        f = func() (err error) {
          for i := len(callbackList) - 1; i >= 0; i-- {
            if callbackList[i] != nil {
              e := callbackList[i]()
              if err == nil {
                err = e
              }
            }
          }
          return
        }
      })
    
      return
    }
    
    ......

### **02单例模式在配置管理中的应用** ###

在Python中，一个很普遍的应用场景就是利用单例模式来实现全局的配置管理。对于大部分的系统，通常都会有一个或者多个配置文件用于存放系统运行时所依赖的各种配置信息，在系统运行的过程中通过代码读取并解析配置文件从而获得对应的配置信息，而且在运行过程中当配置文件发生变更以后还需要实时更新对应的配置信息。

在这个场景里面，如果每次使用重新读取和加载配置，会有以下问题：

*  增加耗时：带来额外的时间开销，额外的开销时间和读取次数成正比。
 *  增加内存：带来额外的内存开销，额外的内存占用和对象的实例个数成正比。

在这个场景里面，有一个典型的特征：需要反复获相同配置文件的内容，配置文件的内容可能会发生变更，所以这个场景就比较合适通过单例模式来实现。即在系统初始化或者首次使用配置的时候加载文件并解析生成一个配置类对象，同时这个对象会实时监听文件内容变更并更新对象的对应属性，后续每次都直接使用这个对象获取文件内容即可。这样即可解决反复读取文件初始化对象以及监听文件变更所来的额外时间和空间开销。

以下为基于Python实现的Demo：

# runtime_conf.py
    
    class RuntimeConf(object):
        """
        单例模式实现的运行时全局配置类
        1、用于解析配置文件并封装成对象属性方便使用
        2、持续监听配置文件，发生变更后自动更新实例对象属性
        """
    
        def __new__(cls):
            if not hasattr(cls, '_instance'):
                # 1、初始化实例对象
                cls._instance = super(RuntimeConf, cls).__new__(cls)
    
                # 2、加载配置文件
                cls._instance.load_config()
    
                # 3、持续开启一个新线程持续监听文件变化，文件发生变更以后更新实例属性
                cls._instance.__watch_async()
    
            return cls._instance
    
        def __watch_async(self):
            """
            私有的监听配置文件方法，如果配置文件发生变更，重新读取配置文件并加载到 self.__data 属性
            :return:
            """
            # 以下仅为示例思路，具体实现文件监听可复用第三方框架，例如 pyinotify
            changed = False
    
            # ......
    
            # 如果文件发生变更，重新加载
            if changed:
                self.__load_config()
    
        def __load_config(self):
            """
            私有读取配置文件并加载到对象属性中
            :return:
            """
            # 读取配置文件并存储到self.__data属性
            self.__data = {
                "key1": 1,
                "key2": 2
            }
            print("load config success")
    
        def get(self, key):
            """
            读取配置
            :param key:
            :return:
            """
            return self.__data.get(key, None)
    
    
    if __name__ == '__main__':
        # 初始化两个对象，输出对象的内存地址，可以发现两个变量都是指向同一个内存地址，即是同一个对象
        conf_1 = RuntimeConf()
        conf_2 = RuntimeConf()
        print(conf_1)
        print(conf_2)
        print(conf_1.get("key1"))
        print(conf_2.get("key2"))

### **03单例模式在IO操作的应用** ###

在PHP中，单例模式一个典型的应用场景，就是IO操作，典型的有数据库、文件操作等，作用在于维护一个全局变量，去管理连接实例。

以典型的PHP站点为例，在标准的MVC结构下，单次网络请求相应过程中，会涉及到多个不同Model的实例化，而每个Model实例又需要进行数据库操作，这里就需要维护全局唯一的数据库连接实例，一般用单例模式进行维护。如果每个Model在实例化时，都建立新的连接，显然是不合理的，会有以下问题：

*  资源浪费：频繁建立连接，增加网络耗时、CPU&内存开销。
 *  无法提交事务：多条SQL语句，不是一个连接提交，无法完整的提交数据库事务。

在这个场景下，我们可以用单例模式解决，单例类可以具备私有的构造函数，并且提供静态方法供外界获取它的实例，外部首次获取时，每次获取到的是同一个对象，由这个对象维护数据库连接。

以下为基于PHP实现的Demo：

class DBHandler {
      private static $instance = null; //私有实例
      public $conn; //数据库连接
    
      //私有构造函数
      private function __construct() {
        $this->conn = new PDO('hostname', 'account', 'password');
      }
    
      //静态方法，用于获取私有实例
      public static function getInstance() {
        if (self::$instance == null) {
          self::$instance = new DBHandler();
        }
        return self::$instance;
      }
     
        public function fetch() {...}
    }
    
    class ModelA {
        private $dbHandler;
        
        public function __construct() {
            $this->dbHandler = DBHandler->getInstance();
        }
        
        public function getA() {
            return $this->dbHandler->fetch($sql);
        }
    }
    
    class ModelB {
        private $dbHandler;
        
        public function __construct() {
            $this->dbHandler = DBHandler->getInstance();
        }
        
        public function getB() {
            return $this->dbHandler->fetch($sql);
        }
    }
    
    $modelA = new ModelA();
    $modelB = new ModelB();
    $modelA->getA();
    $modelB->getB();

### **04单例模式在前端交互的应用** ###

在前端开发中，单例模式的使用十分常见，很多第三方库和框架都应用了单例模式。比如最常用的 js 库 jQuery，它暴露了一个 jQuery 实例，多次引用都只会使用该实例对象。这样的模式，减少了全局变量的创建，并且能够避免变量冲突。

实现单例模式常见的方式有：首先创建一个类，这个类包含一个静态方法，用于创建这个类的实例对象；还存在一个标记，标识实例对象是否已经创建过，如果没有，则创建实例对象并返回；如果创建过，就直接返回首次创建的实例化对象的引用。

在实际应用中，我们常使用单例模式来管理页面中的弹窗，避免页面中同时展现多个互相重叠的弹窗：可以创建一个 Toast 弹窗类，并初始化弹窗节点。这个类提供一个静态方法 getInstance 来创建并返回实例对象，这样业务在创建弹窗时就不需要再进行实例化的操作。业务可以通过 show 和 hide 方法来控制弹窗的展现和隐藏，但即使执行多次 show 方法，也只会展现一个弹窗，因为业务使用的是同一个实例对象。这个类在页面运行时会一直存在，除非没有了对这个类的引用，它则会被垃圾回收。

以下为基于JavaScript实现的Demo：

// 弹窗组件 toast.js
    class Toast {
        constructor() {
            this._init();
        }
        // 私有方法，业务不允许直接调用该方法来创建弹窗
        _init(){
            const toast = document.createElement('div');
            toast.classList.add('toast');
            toast.innerHTML = '这是一个弹窗';
            document.body.append(toast);
        }
        show() {
            document.querySelector('.toast').style.display = 'block';
        }
        hide() {
            document.querySelector('.toast').style.display = 'none';
        }
        // 静态方法，业务操作弹窗时不需要再实例化
        static getInstance() {
            if(!this.instance) {
                this.instance = new Toast();
            }
            return this.instance;
        }
    }
    // 在组件中把对唯一的实例对象 loginToast 的引用暴露出去
    const toast = Toast.getInstance();
    export default toast;
    
    // 业务调用
    import toast from './xxx/toast';
    toast.show();

[8db3f7b4a18f994c7e1259fb3a8bb90e.png]: https://img-blog.csdnimg.cn/img_convert/8db3f7b4a18f994c7e1259fb3a8bb90e.png