单例模式
<p><em>摘要</em></p>
<p>目录单例模式的概念单例模式结构单例模式的使用场景单例模式例子：特殊的计数器第一个单元测试单例模式实现单例模式优缺点单例模式的概念单例模式很容易记住。就像名称一样，它只能提供对象的单一实例，保证一个类只有一个实例，并提供一个全局访问该实例的</p>
<h5>目录</h5>
<ul>
<li>单例模式的概念</li>
<li>单例模式结构</li>
<li>单例模式的使用场景</li>
<li>
<p>单例模式例子：特殊的计数器</p>
</li>
<li>
<p>第一个单元<a href="https://www.lsjlt.com/tag/%E6%B5%8B%E8%AF%95/"><strong>测试</strong></a></p>
</li>
<li>
<p>单例模式实现</p>
</li>
<li>单例模式优缺点</li>
</ul>
<h2>单例模式的概念</h2>
<p>单例模式很容易记住。就像名称一样，它只能提供对象的单一实例，保证一个类只有一个实例，并提供一个全局访问该实例的方法。</p>
<p>在第一次调用该实例时被创建，然后在应用程序中需要使用该特定行为的所有部分之间重复使用。</p>
<h2>单例模式的使用场景</h2>
<p>你会在许多不同的情况下使用单例模式。比如：</p>
<ul>
<li>当你想使用同一个<a href="https://www.lsjlt.com/tag/%E6%95%B0%E6%8D%AE%E5%BA%93/"><strong>数据库</strong></a>连接来进行每次查询时</li>
<li>当你打开一个<a href="https://www.lsjlt.com/tag/%E5%AE%89%E5%85%A8/"><strong>安全</strong></a> <a href="https://www.lsjlt.com/tag/shell/"><strong>shell</strong></a>（<a href="https://www.lsjlt.com/tag/ssh/"><strong>ssh</strong></a>）连接到一个<a href="https://www.lsjlt.com/tag/%E6%9C%8D%E5%8A%A1%E5%99%A8/"><strong>服务器</strong></a>来做一些任务时。 而不想为每个任务重新打开连接</li>
<li>如果你需要限制对某些变量或空间的访问，你可以使用一个单例作为 作为这个变量的门（在 <a href="https://www.lsjlt.com/tag/Go/"><strong>Go</strong></a> 中使用通道可以很好地实现）</li>
<li>如果你需要限制对某些空间的调用数量，你可以创建一个单例实例使得这种调用只在可接受的窗口中进行</li>
</ul>
<p>单例模式还有跟多的用途，这里只是简单的举出一些。</p>
<h2>单例模式优缺点</h2>
<p>优点：</p>
<ul>
<li>你可以保证一个类只有一个实例。</li>
<li>你获得了一个指向该实例的全局访问节点。</li>
<li>仅在首次请求单例对象时对其进行初始化。</li>
</ul>
<p>缺点：</p>
<ul>
<li>违反了<strong>单一职责原则</strong>。 该模式同时解决了两个问题。</li>
<li>单例模式可能掩盖不良设计， 比如程序各组件之间相互了解过多等。</li>
<li>该模式在<a href="https://www.lsjlt.com/tag/%E5%A4%9A%E7%BA%BF%E7%A8%8B/"><strong>多线程</strong></a>环境下需要进行特殊处理， 避免多个<a href="https://www.lsjlt.com/tag/%E7%BA%BF%E7%A8%8B/"><strong>线程</strong></a>多次创建单例对象。</li>
<li>单例的客户端代码单元测试可能会比较困难， 因为许多测试<a href="https://www.lsjlt.com/tag/%E6%A1%86%E6%9E%B6/"><strong>框架</strong></a>以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。</li>
</ul>
<p>设计模式的重要性不用多说，也是面试时常常会被问到的问题。对于设计模式，更多的则是仁者见仁智者见智，要在实际工作中不断的积累，再进行深度的思考，才能逐渐形成的一种思维。</p>
<p>单例模式也叫单子模式，是常用的模式之一，在它的核心结构中只包含一个被称为单例的特殊类，能够保证系统运行中一个类只创建一个实例，本节我们就来介绍一下Go语言中的单例模式。</p>
<h2><strong>单例模式实现</strong></h2>
<p>Go语言实现单例模式的有四种方式，分别是懒汉式、饿汉式、双重检查和 sync.Once。</p>
<p>懒汉式就是创建对象时比较懒，先不急着创建对象，在需要加载配置文件的时候再去创建；饿汉式则是在系统初始化的时候就已经把对象创建好了，需要用的时候直接拿过来用就好了。</p>
<p>不管那种模式最终目的只有一个，就是只实例化一次，只允许一个实例存在。</p>
<p>下面就来分别介绍一下这四种实现方式：</p>
<p>1) 懒汉式——非线程安全</p>
<p>非线程安全，指的是在多线程下可能会创建多次对象。</p>
<pre><code>//使用结构体代替类
type Tool struct {
values int
}
//建立私有变量
var instance *Tool
//获取单例对象的方法，引用传递返回
func GetInstance() *Tool {
if instance == nil {
instance = new(Tool)
}
return instance
}</code></pre>
<p>在非线程安全的基本上，利用 Sync.Mutex 进行加锁保证线程安全，但由于每次调用该方法都进行了加锁操作，在性能上不是很高效。</p>
<pre><code>//锁对象
var lock sync.Mutex
//加锁保证线程安全
func GetInstance() *Tool {
lock.Lock()
defer lock.Unlock()
if instance == nil {
instance = new(Tool)
}
return instance
}</code></pre>
<p>2) 饿汉式</p>
<p>直接创建好对象，不需要判断为空，同时也是线程安全，唯一的缺点是在导入包的同时会创建该对象，并持续占有在内存中。 </p>
<p>Go语言饿汉式可以使用 init 函数，也可以使用全局变量。</p>
<pre><code>type cfg struct {
}
var cfg *config
func init() {
cfg = new(config)
}
// NewConfig 提供获取实例的方法
func NewConfig() *config {
return cfg
}
type config struct {
}
//全局变量
var cfg *config = new(config)
// NewConfig 提供获取实例的方法
func NewConfig() *config {
return cfg
}</code></pre>
<p>3) 双重检查</p>
<p>在懒汉式（线程安全）的基础上再进行优化，减少加锁的操作，保证线程安全的同时不影响性能。</p>
<pre><code>//锁对象
var lock sync.Mutex
//第一次判断不加锁，第二次加锁保证线程安全，一旦对象建立后，获取对象就不用加锁了。
func GetInstance() *Tool {
if instance == nil {
lock.Lock()
if instance == nil {
instance = new(Tool)
}
lock.Unlock()
}
return instance
}</code></pre>
<p>5) sync.Once</p>
<p>通过 sync.Once 来确保创建对象的方法只执行一次</p>
<pre><code>var once sync.Once
func GetInstance() *Tool {
once.Do(func() {
instance = new(Tool)
})
return instance
}</code></pre>
<p>sync.Once 内部本质上也是双重检查的方式，但在写法上会比自己写双重检查更简洁，以下是 Once 的源码</p>
<pre><code>func (o *Once) Do(f func()) {
//判断是否执行过该方法，如果执行过则不执行
if atomic.LoadUint32(&amp;o.done) == 1 {
return
}
// Slow-path.
o.m.Lock()
defer o.m.Unlock()
//进行加锁，再做一次判断，如果没有执行，则进行标志已经扫行并调用该方法
if o.done == 0 {
defer atomic.StoreUint32(&amp;o.done, 1)
f()
}
}</code></pre>
<p>使用懒惰模式的单例模式，使用双重检查加锁保证线程安全</p>
<h4>singleton.go</h4>
<pre><code>package singleton
import &quot;sync&quot;
//Singleton 是单例模式类
type Singleton struct{}
var singleton *Singleton
var once sync.Once
//GetInstance 用于获取单例模式对象
func GetInstance() *Singleton {
once.Do(func() {
singleton = &amp;Singleton{}
})
return singleton
}</code></pre>
<h4>singleton_test.go</h4>
<pre><code>package singleton
import (
&quot;sync&quot;
&quot;testing&quot;
)
const parCount = 100
func TestSingleton(t *testing.T) {
ins1 := GetInstance()
ins2 := GetInstance()
if ins1 != ins2 {
t.Fatal(&quot;instance is not equal&quot;)
}
}
func TestParallelSingleton(t *testing.T) {
wg := sync.WaitGroup{}
wg.Add(parCount)
instances := [parCount]*Singleton{}
for i := 0; i &lt; parCount; i++ {
go func(index int) {
instances[index] = GetInstance()
wg.Done()
}(i)
}
wg.Wait()
for i := 1; i &lt; parCount; i++ {
if instances[i] != instances[i-1] {
t.Fatal(&quot;instance is not equal&quot;)
}
}
}</code></pre>