设计模式-单列模式

 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

package main

import (
	"sync"
)

type singleton struct{}

//1.懒汉方式--不能并发
var ins1 *singleton

func getInstance1() *singleton {
	if ins1 == nil {
		ins1 = &singleton{}
	}
	return ins1
}

//2.饿汉方式--初始化消耗大
var ins2 *singleton = &singleton{}

func getInstance2() *singleton {
	return ins2
}

//3.懒汉加锁--解决并发，加锁代价高
var ins3 *singleton
var mu sync.Mutex

func getInstance3() *singleton {
	mu.Lock()
	defer mu.Unlock()

	if ins3 == nil {
		ins3 = &singleton{}
	}
	return ins3
}

//4.加锁前判断两次--避免加锁，提高效率
var ins4 *singleton
var mu4 sync.Mutex

func getInstance4() *singleton {
	if ins4 == nil {
		mu.Lock()
		defer mu.Unlock()

		if ins4 == nil {
			ins4 = &singleton{}
		}
	}
	return ins4
}

//sync.Once实现
var ins5 *singleton
var once sync.Once

func getInstance5() *singleton {
	once.Do(func() {
		ins5 = &singleton{}
	})
	return ins5
}