设计模式-单例模式(Go语言描述)

75 阅读 0 评论 50 点赞

我是靠谱客的博主受伤舞蹈，最近开发中收集的这篇文章主要介绍设计模式-单例模式(Go语言描述)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

这篇博客我们继续来看设计模式，今天带来的是一个最简单而且最常用的模式-单例模式。那什么是单例模式呢？相信大家最它最熟悉不过了，那我们就来快速的了解一下它的定义。

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

这个解释足够简单。说白了就是假如我们希望我们在我们的系统中该类仅仅存在1个或0个该类的实例。虽然单例模式很简单，但是熟悉java的同学可能了解，单例模式有很多写法,懒汉式、饿汉式、双重锁。。。这么多形式，难道有什么目的？确实，不过他们的目的很明确，就是保证在一种特殊情况下的单例-并发。

ok，既然了解了单例模式，那下面我们就开始用代码描述一下单例模式。首先是最简单的单例，这里我们并不去考虑并发的情况。

package manager
import (
    "fmt"
)

var m *Manager

func GetInstance() *Manager {
    if m == nil {
        m = &Manager {}
    }
    return m
}

type Manager struct {}

func (p Manager) Manage() {
    fmt.Println("manage...")
}

这就是一个最简单的单例了，对于Manager结构体，我们提供了一个GetInstance函数去获取它的实例，这个函数中首先去判断m变量是否为空，如果为空才去赋值一个Manager的指针类型的值，一个小小的判断，就保证了我们在第第二次调用GetInstance的时候直接返回m，而不是重新获取Manager的实例，进而保证了唯一实例。

上面的代码确实简单，也实现了最简单的单例模式，不过大家有没有考虑到并发这一点，在并发的情况下，这里是不是还可以正常工作呢？来，先跟着下面的思路走一走，来看看问题出现在哪。

现在我们是在并发的情况下去调用的 GetInstance函数，现在恰好第一个goroutine执行到m = &Manager {}这句话之前，第二个goroutine也来获取实例了，第二个goroutine去判断m是不是nil,因为m = &Manager{}还没有来得及执行，所以m肯定是nil，现在出现的问题就是if中的语句可能会执行两遍！

在上面介绍的这种情形中，因为m = &Manager{}可能会执行多次，所以我们写的单例失效了，这个时候我们就该考虑为我们的单例加锁啦。

这个时候我们就需要引入go的锁机制-sync.Mutex了,修改我们的代码，

package manager
import (
    "sync"
    "fmt"
)

var m *Manager
var lock *sync.Mutex = &sync.Mutex {}

func GetInstance() *Manager {
    lock.Lock()
    defer lock.Unlock()
    if m == nil {
        m = &Manager {}
    }
    return m
}

type Manager struct {}

func (p Manager) Manage() {
    fmt.Println("manage...")
}

代码做了简单的修改了，引入了锁的机制，在GetInstance函数中，每次调用我们都会上一把锁，保证只有一个goroutine执行它，这个时候并发的问题就解决了。不过现在不管什么情况下都会上一把锁，而且加锁的代价是很大的，有没有办法继续对我们的代码进行进一步的优化呢？熟悉java的同学可能早就想到了双重的概念，没错，在go中我们也可以使用双重锁机制来提高效率。

package manager
import (
    "sync"
    "fmt"
)

var m *Manager
var lock *sync.Mutex = &sync.Mutex {}

func GetInstance() *Manager {
    if m == nil {
        lock.Lock()
        defer lock.Unlock()
        if m == nil {
            m = &Manager {}
        }
    }

    return m
}

type Manager struct {}

func (p Manager) Manage() {
    fmt.Println("manage...")
}

代码只是稍作修改而已，不过我们用了两个判断，而且我们将同步锁放在了条件判断之后，这样做就避免了每次调用都加锁，提高了代码的执行效率。

这获取就是很完美的单例代码了，不过还没完，在go中我们还有更优雅的方式去实现。单例的目的是啥？保证实例化的代码只执行一次，在go中就中这么一种机制来保证代码只执行一次，而且不需要我们手工去加锁解锁。对，就是我们的sync.Once，它有一个Do方法，在它中的函数go会只保证仅仅调用一次！再次修改我们的代码，

package manager
import (
    "sync"
    "fmt"
)

var m *Manager
var once sync.Once

func GetInstance() *Manager {
    once.Do(func() {
        m = &Manager {}
    })
    return m
}

type Manager struct {}

func (p Manager) Manage() {
    fmt.Println("manage...")
}

代码更简单了，而且有没有发现-漂亮了！Once.Do方法的参数是一个函数，这里我们给的是一个匿名函数，在这个函数中我们做的工作很简单，就是去赋值m变量，而且go能保证这个函数中的代码仅仅执行一次！

ok，到现在单例模式我们就介绍完了，内容并不多，因为单例模式太简单而且太常见了。我们用单例的目的是为了保证在整个系统中存在唯一的实例，我们加锁的目的是为了在并发的环境中单例依旧好用。不过虽然单例简单，我们还是不能任性的用，因为这样做实例会一直存在内存中，一些我们用的不是那么频繁的东西使用了单例是不是就造成了内存的浪费？大家在用单例的时候还是要多思考思考，这个模块适不适合用单例！