go设计模式——单例模式

单例模式主要有两种：懒汉式和饿汉式

//懒汉式--非线程安全
//使用结构体代替类
type Tool struct {
	values int
}
//建立私有变量
var instance *Tool
//获取单例对象的方法，引用传递返回
func GetInstance()*Tool{
	if instance==nil{
		instance=new(Tool)
	}
	return instance
}

　　

//懒汉式--线程安全--每次操作进行加锁操作-性能不是很高
//使用结构体代替类

type Tool struct {
	values int
}
//建立私有变量
var instance *Tool
//锁对象
var lock sync.Mutex
//获取单例对象的方法，引用传递返回
func GetInstance()*Tool{
	lock.Lock()
	defer lock.Unlock()
	if instance==nil{
		instance=new(Tool)
	}
	return instance
}

　　

//懒汉式--双重检查
//在懒汉式（线程安全）的基础上再进行优化，减少加锁的操作，保证线程安全的同时不影响性能

//使用结构体代替类
type Tool struct {
	values int
}
//锁对象
var lock sync.Mutex
var instance *Tool
//第一次判断不加锁，第二次加锁保证线程安全，一旦对象建立后，获取对象就不用加锁了。
func GetInstance()*Tool{
	if instance==nil{
		lock.Lock()
		if instance ==nil{
			instance=new(Tool)
		}
		lock.Unlock()
	}
	return instance
}

　　

//饿汉式--init()函数创建
//线程安全，唯一的缺点是在导入包的同时会创建该对象，并持续占有在内存中
type  Tool struct {
}
var tool *Tool
//初始化一个实例
func init(){
　　tool=new(Tool)
}

//NewConfig 提供获取实例的方法
func NewTool()*Tool{
　　return tool
}

　　

//饿汉式--全局变量方式创建
//线程安全，唯一的缺点是在导入包的同时会创建该对象，并持续占有在内存

type Tool struct {
}
//全局变量
var tool *Tool = new(Tool)
// NewConfig 提供获取实例的方法
func NewConfig() *Tool {
	return tool
}

通过 sync.Once 来确保创建对象的方法只执行一次----具有双重检查的效果，sync.Once内部已封装判断

var once sync.Once
func GetInstance() *Tool{
	once.Do(func() {
		instance = new(Tool)
	})
	return instance
}