首页 设计模式

# 单例模式解决什么问题

  • 处理资源访问冲突
  • 表示全局唯一。在整个程序中，某些数据应该存储一份，这样的类，就应该设计成单例类。比如，SpringBoot 应用的配置项。再比如 雪花算法的实现类。

# 实现单例

如何实现单例呢，或者说怎样能称得上单例呢？
首先，单例要求全局唯一，那就是说 不允许外部随随便便 new 一个新对象.

这句话里，至少有两个点:
1. 不允许外部 new 对象。 2. 需要类内部 new 对象，并提供给外部进行使用。
其实很简单的，单例类的构造方法需要是 private 权限的，提供一个 public 方法，用于外部获取本对象。

另外，我们写的程序都是运行在多线程环境的，所以我们还需要考虑线程安全的问题。
还有，说过线程安全，自然而然，就会想到锁，想到锁，就要想到性能问题。

# 核心概念

保证某个类在一个运行环境中只有一个实例， 并提供一个访问该实例的全局节点。

# 单例的实现

# 懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package singleton

import "sync"

var (
	lazySingletonInstance *lazySingleton
	once                  = &sync.Once{}
)

// LazySingleton 懒汉式
type lazySingleton struct {
}

func GetLazySingletonInstance() *lazySingleton {
	if lazySingletonInstance == nil {
		once.Do(func() {
			lazySingletonInstance = &lazySingleton{}
		})
	}
	return lazySingletonInstance
}

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package singleton

import "testing"

func TestGetLazySingletonInstance(t *testing.T) {
	if GetLazySingletonInstance() != GetLazySingletonInstance() {
		t.Error("懒汉式 单例模式： 出现同一对象")
	}
}

func BenchmarkGetLazySingletonInstance(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if GetLazySingletonInstance() != GetLazySingletonInstance() {
			b.Error("懒汉式 单例模式： 出现同一对象")
		}
	}
}

# 饿汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package singleton

import "fmt"

type eagerSingleton struct {
}

var eagerSingletonObj *eagerSingleton

// init.  程序运行前的注册，实现 sync.Once功能 ,初始化不能采用初始化表达式初始化的变量。
// 变量初始化->init()->main()
func init() {
	fmt.Println("init in main.go ")
	eagerSingletonObj = &eagerSingleton{}
}

func GetInstance() *eagerSingleton {
	return eagerSingletonObj
}

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package singleton

import "testing"

func TestEagerSingleton(t *testing.T) {
	if GetInstance() != GetInstance() {
		t.Error("单例模式-饿汉式：出现不同的对象")
	}
}

func BenchmarkGetInstance(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if GetInstance() != GetInstance() {
			b.Error("单例模式-饿汉式：出现不同的对象")
		}
	}
}

# 双重检查锁

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
package singleton

import (
	"fmt"
	"sync"
)

type doubleCheckSingleton struct {
}

var lock = &sync.Mutex{}

var doubleCheckSingletonInstance *doubleCheckSingleton

func GetDoubleCheckSingletonInstance() *doubleCheckSingleton {
	if doubleCheckSingletonInstance == nil {
		lock.Lock()
		defer lock.Unlock()
		if doubleCheckSingletonInstance == nil {
			fmt.Println("创建 单例对象")
			doubleCheckSingletonInstance = &doubleCheckSingleton{}
		} else {
			fmt.Println("单例对象已经创建了")
		}
	} else {
		fmt.Println("单例对象已经创建了")
	}

	return doubleCheckSingletonInstance
}

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package singleton

import "testing"

func TestGetDoubleCheckSingletonInstance(t *testing.T) {
	if GetDoubleCheckSingletonInstance() != GetDoubleCheckSingletonInstance() {
		t.Error("双重检测法 获取不同的对象")
	}
}

func BenchmarkGetDoubleCheckSingletonInstance(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if GetDoubleCheckSingletonInstance() != GetDoubleCheckSingletonInstance() {
			b.Error("双重检测法 获取不同的对象")
		}
	}
}

# 问题

1、单例模式同事解决了两个问题，所以单例模式违反了单一职责原则:

  • 1、保证一个类只有一个实例.
  • 2、为该实例提供了一个全局访问节点.
    2、单例模式可能会掩盖不良设计，比如程序各组件之间项目了解过多。
    3、该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。
    4、单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。

# 与其他模式的关系

  • 外观模式类通常可以转换为单例模式类， 因为在大部分情况下一个外观对象就足够了。
  • 如果你能将对象的所有共享状态简化为一个享元对象， 那么享元模式就和单例类似了。 但这两个模式有两个根本性的不同。
    • 只会有一个单例实体， 但是享元类可以有多个实体， 各实体的内在状态也可以不同。
    • 单例对象可以是可变的。 享元对象是不可变的。
  • 抽象工厂模式、 生成器模式和原型模式都可以用单例来实现。

# 最后

希望和你一起遇见更好的自己