[设计模式 in Golang]单例模式

た入场券 2022-09-12 09:53 156阅读 0赞

# 前言 #

单例模式是最简单的一个模式，指的是全局只有一个实例，并且它负责创建自己的对象。

单例模式不仅有利于减少内存开支，还有减少系统性能开销、防止多个实例产生冲突等优点。  
因为单例模式保证了实例的全局唯一性，而且只被初始化一次，所以比较适合全局共享一个实例，且只需要被初始化一次的场景，例如数据库实例、全局配置、全局任务池等。

# 两个方式 #

单例模式又分为饿汉方式和懒汉方式。

## 饿汉方式 ##

饿汉方式指全局的单例实例在包被加载时创建，

go中有两种常见写法，一种是利用全局变量的初始化：

package singleton
    
    type singleton struct {
        
    }
    
    var instance = &singleton{
        }
    
    func getInstance() *singleton {
        
    	return instance
    }

或者可以通过使用init函数，init函数会在package被加载时执行一次，从而避开了并发：

package singleton
    
    type singleton struct {
        
    }
    
    var instance *singleton
    
    func getInstance() *singleton {
        
    	return instance
    }
    
    func init() {
        
    	instance = &singleton{
        }
    }

我们可以写个测试验证确实getInstance返回的是同一个实例：

package singleton
    
    import (
    	"github.com/stretchr/testify/assert"
    	"testing"
    )
    
    func Test_getInstance(t *testing.T) {
        
    	assert.Equal(t, getInstance(), getInstance())
    	assert.Equal(t, getInstance(), instance)
    }

$ go test -v
    === RUN   Test_getInstance
    --- PASS: Test_getInstance (0.00s)
    PASS
    ok      ……/demo      1.660s

饿汉模式没有线程安全性问题，不需要考虑懒加载，获取实例的效率特高。缺点是如果初始化比较耗时，会导致程序加载时间比较长；即使没有用到这个对象，只要import路径里有它也照样要进行初始化。

PS：业务中看到有的人会在初始化代码中写一些外部依赖的代码，比如ping个网络地址，甚至还写个如果失败的话就panic，这就给本地测试等带来了很大的麻烦。这种饿汉模式简直是灾难。

## 懒汉模式 ##

现在流行懒汉模式“延迟加载”，换句话说，在第一次使用这个单例类的时候才实际创建并初始化这个实例。

一个最简单的懒汉模式示例代码如下：

package singleton
    
    type singleton struct {
        
    }
    
    var instance *singleton
    
    func getInstance() *singleton {
        
    	if instance == nil {
        
    		instance = &singleton{
        }
    	}
    	return instance
    }

package singleton
    
    import (
    	"github.com/stretchr/testify/assert"
    	"testing"
    )
    
    func Test_getInstance(t *testing.T) {
        
    	assert.Nil(t, instance)
    	assert.Equal(t, getInstance(), getInstance())
    	assert.NotNil(t, instance)
    	assert.Equal(t, getInstance(), instance)
    }

这个代码在单线程的环境下工作良好，但是在多线程环境下会有并发问题，如果两个线程同时`getInstance`，可能会创建出两个实例。

经典的线程安全的懒汉模式go语言实现示例如下：

package singleton
    
    import "sync"
    
    type singleton struct {
        
    }
    
    var (
    	instance *singleton
    	lock     sync.Mutex
    )
    
    func getInstance() *singleton {
        
    	if instance == nil {
        
    		lock.Lock()
    		if instance == nil {
        
    			instance = &singleton{
        }
    		}
    		lock.Unlock()
    	}
    	return instance
    }

当发现instance为nil后，会加锁准备创建对象，加锁成功后必须重新检查是否为nil，应为可能被并发的另一个线程抢先创建了。

在go语言中，我们还可以使用Once实现只初始化一次(看着好像更高端了)：

package singleton
    
    import "sync"
    
    type singleton struct {
        
    }
    
    var (
    	instance *singleton
    	once     sync.Once
    )
    
    func getInstance() *singleton {
        
    	once.Do(func() {
        
    		instance = &singleton{
        }
    	})
    	return instance
    }

Once可以保证只执行一次，且在执行时阻塞同时想要执行的其他线程。

肯定有小可爱觉得这样的写法更好：

func getInstance() *singleton {
        
    	if instance == nil {
        
    		once.Do(func() {
        
    			instance = &singleton{
        }
    		})
    	}
    	return instance
    }

但是实际上，通过基准测试发现，两种写法的性能没啥差。

# 结语 #

好像没什么好写的，这是最简单的设计模式，就算没学过设计模式也几乎在实际工作中会使用到。了解一下即可。