GO设计模式01单例模式

Posted 2021-06-26 XY丶YX

（注：本文为http://c.biancheng.net/view/1317.html学习笔记）

一、概述

单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。

func main() {
	fmt.Println("hello")
	lanhan := GetLanHan()
	//lanhan := GetEHan()
	//lanhan := GetLanHanSync()
	//lanhan := GetDoubleSync()
	//lanhan := GetSyncOnce()
	fmt.Println(lanhan.name)
}

二、饿汉式

package main
//饿汉方式：指全局的单例实例在类装载时构建。
//缺点：如果singleton创建初始化比较复杂耗时时，加载时间会延长。
type EHanSingleton struct{
	name string
}

var ehanins  *EHanSingleton = &EHanSingleton{"饿汉式"}

func GetEHan() *EHanSingleton{
	return ehanins
}

三、懒汉式

package main
//懒汉方式：指全局的单例实例在第一次被使用时构建。
//缺点：非线程安全。当正在创建时，有线程来访问此时ins = nil就会再创建，单例类就会有多个实例了。
type LanHanSingleton struct{
	name string
}

var lanhanins *LanHanSingleton

func GetLanHan() *LanHanSingleton{
	if lanhanins == nil {
		lanhanins = &LanHanSingleton{"懒汉式"}
	}
	return lanhanins
}

四、加锁懒汉式

package main

import "sync"

//缺点：虽然解决并发的问题，但每次加锁是要付出代价的
type LanHanSyncSingleton struct{
	name string
}

var lanHanSyncIns *LanHanSyncSingleton
var mu sync.Mutex

func GetLanHanSync() *LanHanSyncSingleton{
	mu.Lock()
	defer mu.Unlock()
	if lanHanSyncIns == nil {
		lanHanSyncIns = &LanHanSyncSingleton{"懒汉式加锁"}
	}
	return lanHanSyncIns
}

五、懒汉式双重加锁

package main

import "sync"
//避免了每次加锁，提高代码效率
type DoubleSyncSingleton struct{
	name string
}

var doubleSyncIns *DoubleSyncSingleton
var mu2 sync.Mutex

func GetDoubleSync() *DoubleSyncSingleton{
	if doubleSyncIns == nil {
		mu2.Lock()
		defer mu2.Unlock()
		if doubleSyncIns == nil{
			doubleSyncIns = &DoubleSyncSingleton{"懒汉式双重加锁"}
		}
	}
	return doubleSyncIns
}

六、go特有的sync.Once

package main

import "sync"

type OnceSingleton struct{
	name string
}

var synconceins *OnceSingleton
var once sync.Once

func GetSyncOnce() *OnceSingleton{
	once.Do(func() {
		synconceins = &OnceSingleton{"sync.Once"}
	})
	return synconceins
}