[转]Golang 单例模式实现（n种）

感谢作者，原文这里。

单例模式在开发中是一种相对简单的设计模式，但它在实现上又有很多种方式

熟悉java的同学知道在java中实现单例常见的有懒汉式、饿汉式、双重检查、内部静态类、枚举单例等（传送门）

而由于语言的特性，golang目前常见的有以下四种方式（懒汉式、饿汉式、双重检查、sync.Once）

1.懒汉式----非线程安全

非线程安全，即在多线程下可能会创建多次对象

/**

* 使用结构体代替类

*/type Tool struct {

    values int}/**

* 建立私有变量

*/varinstance *Tool/**

* 获取单例对象的方法，引用传递返回

*/func GetInstance() *Tool {

    ifinstance == nil {

        instance =new(Tool)

    }

    return instance

}

2.懒汉式----线程安全

在非线程安全的基本上，利用Sync.Mutex进行加锁,保证线程安全，但由于每次调用该方法都进行了加锁操作，在性能上相对不高效

/**

* 锁对象

*/varlock sync.Mutex/**

* 加锁保证线程安全

*/func GetInstance() *Tool {

    lock.Lock()

    defer lock.Unlock()

    ifinstance == nil {

        instance =new(Tool)

    }

    return instance

}

3.饿汉式

直接创建好对象，这样不需要判断为空，同时也是线程安全。唯一的缺点是在导入包的同时会创建该对象，并持续占有在内存中。

varinstanceToolfunc GetInstance() *Tool {

    return &instance

}

4.双重检查

在懒汉式（线程安全）的基础上再进行忧化，判断加锁的操作。保证线程安全同时不影响性能

/**

* 锁对象*/varlock sync.Mutex/**

* 第一次判断不加锁，第二次加锁保证线程安全，一旦对象建立后,获取对象就不用加锁了*/func GetInstance() *Tool {

    ifinstance == nil {

        lock.Lock()

        ifinstance == nil {

            instance =new(Tool)

        }

        lock.Unlock()

    }

    return instance

}

5.sync.Once

通过sync.Once 来确保创建对象的方法只执行一次

var once sync.Once

func GetInstance() *Tool {

    once.Do(func() {

        instance =new(Tool)

    })

    return instance

}

sync.Once内部本质上也是双重检查的方式，但在写法上会比自己写双重检查更简洁，以下是Once的源码

func (o *Once) Do(f func()) {

//判断是否执行过该方法，如果执行过则不执行

ifatomic.LoadUint32(&o.done) ==1 {

        return    }

    // Slow-path.o.m.Lock()    defer o.m.Unlock()

//进行加锁，再做一次判断，如果没有执行，则进行标志已经扫行并调用该方法

ifo.done ==0 {

        defer atomic.StoreUint32(&o.done,1)

        f()

    }

}

这样，知道哪种方式最优了吗？