设计模式——单例模式

设计模式——单例模式

1. 设计模式分为创建型、结构型、行为型三大类。
2. 创建型设计模式主要解决“对象的创建”问题
   1. 比较常用的有单例模式和工厂模式，相关链接如下：
   2. 设计模式——单例模式
   3. 设计模式——工厂模式
3. 结构型设计模式主要解决“类或对象的组合”问题
   1. 比较常用的有代理模式，装饰器模式，相关链接如下：
   2. 设计模式——代理模式
   3. 设计模式——装饰器模式
4. 行为型设计模式主要解决的就是“类或对象之间的交互”问题
   1. 比较常用的有观察者模式，策略模式，模板模式
   2. 设计模式——观察者模式
   3. 设计模式——策略模式
   4. 设计模式——模板模式

---

目录

1. 为什么要使用单例？使用场景？
2. 模式结构
3. 单例模式优点？
4. 单例模式缺点？
5. 单例模式代码实现

1. 为什么要使用单例？使用场景？

1. 对在系统中的某些类，只需要一个全局的实例，比如管理配置的类或者写log的类，单例模式就能提供这样的功能，能够节省资源，防止多个实例产生冲突。
   a. 比如创建多个log对象在多线程环境下同时写日志到log.txt中，可能会存在日志信息相互覆盖的情况。
   b. 因为多线程环境下，如果两个线程同时给一个共享变量加1，因为共享变量是竞争资源，所以，共享变量最后的结果有可能并不是加了2，而是加了1。
   c. 同理，log.txt 文件也是竞争资源，两个线程同时往里面写数据，就有可能存在互相覆盖的情况。

2. 模式结构

1. 单例模式包含：Singleton单例对象
   

3. 单例模式优点？

1. 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式可以提高系统的性能，同时也防止了多个实例产生冲突。

4. 单例模式缺点？

1. 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
2. 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。

5. 单例模式代码实现

1. 常见的单例模式实现方式有饿汉式、懒汉式和双端检测方式。

1. 饿汉式

1. 饿汉式在类加载的时候，instance 静态实例就已经创建并初始化好。
2. 所以，instance 实例的创建过程是线程安全的。
3. 不过，这样的实现方式不支持延迟加载（即在真正用到 IdGenerator 的时候，再创建实例）
4. 具体的代码实现如下所示：

class singleton {
private:
    singleton(){}

private:
    static singleton *p;
public:
    static singleton *getInstance();
};

singleton *singleton::p = new singleton();

singleton *singleton::getInstance() {
    return p;
}

2. 懒汉式

1. 懒汉式相对于饿汉式的优势是支持延迟加载，需要的时候才创建。
2. 要注意并发调用创建函数的场景，需要用锁或其他并发控制原语来控制实例只会创建一次。
3. 具体的代码实现如下所示：

class singleton {
private:
    singleton() {}

private:
    static singleton *p;

public:
    static singleton *getInstance();
};

singleton *singleton::p = nullptr;

singleton *singleton::getInstance() {
    if (p == nullptr) {
        p = new singleton();
    }
    return p;
}

3. 双重检测

1. 饿汉式不支持延迟加载，懒汉式有性能问题，不支持高并发。双重检测实现方式既支持延迟加载、又支持高并发的单例实现方式

class singleton {
private:
    singleton(){}

private:
    static singleton *p;

public:
    static pthread_mutex_t mutex;

    static singleton *getInstance();
};

pthread_mutex_t singleton::mutex;
singleton *singleton::p = nullptr;

singleton *singleton::getInstance() {
    if (p == nullptr) {
        pthread_mutex_lock(&mutex);
        if (p == nullptr) {
            p = new singleton();
        }
        pthread_mutex_unlock(&mutex);
    }
    return p;
}

4. go版本使用sync标准库实现

1. sync库里面有Once类，可以控制某个逻辑只会执行一次，需要单例时直接使用该方式会很方便。

package main

import (
	"fmt"
	"sync"
)

type Singleton interface {
	getValue() int
}

type singleton struct {
	Value int
}

func (s *singleton) getValue() int {
	return s.Value
}

var (
	instance *singleton
	once     sync.Once
)

func GetInstance(v int) Singleton {
	once.Do(func() {
		instance = &singleton{
			Value: v,
		}
	})
	return instance
}

func main() {
	ins1 := GetInstance(1)
	ins2 := GetInstance(2)
	if ins1 != ins2 {
		fmt.Println("instance is not equal")
	} else {
		fmt.Println("instance is equal")
	}
}