头图

手撸golang 创建型设计模式 单例模式

ioly

手撸golang 创建型设计模式 单例模式

缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之

单例模式

单例模式(Singleton Pattern)指确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点,属于创建型设计模式。
_

三种常见单例模式

  • 饿汉式单例

    • 类/模块初始化时立即创建的静态全局单例
  • 双重检查单例

    • 提供获取单例的方法
    • 在该方法中通过双重检查静态实例是否为null, 以延迟初始化全局单例
    • 首次检查不加同步锁, 二次检查加同步锁, 以保证单例只创建一次
  • 容器式单例

    • 存在全局唯一的Bean容器
    • 通过Bean的名称读取或设置与该名称绑定的bean单例
    • 通过读写锁控制并发安全
    • 常用于需要持有大量单例的场景, 如IOC容器

单元测试

singleton_test.go, 依次调用了三种单例的方法

package patterns

import "testing"
import (sg "learning/gooop/creational_patterns/singleton")

func Test_Singleton(t *testing.T) {
    fnTestSingleton := func(it sg.IDemoSingleton) {
        it.Hello()
    }

    fnTestSingleton(sg.HungrySingleton)
    fnTestSingleton(sg.GetDualCheckSingleton())

    ok, it := sg.DefaultBeanContaibner.GetBean("IDemoSingleton")
    if ok {
        fnTestSingleton(it.(sg.IDemoSingleton))
    }
}

测试输出

$ go test -v singleton_test.go 
=== RUN   Test_Singleton
tHungrySingleton.Hello
tDualCheckSingleton.Hello
tContainedSingleton.Hello
--- PASS: Test_Singleton (0.00s)
PASS
ok      command-line-arguments  0.002s

IDemoSingleton.go

定义单例的接口

package singleton

type IDemoSingleton interface {
    Hello()
}

饿汉式单例

HungrySingleton.go演示如何实现一个饿汉式单例

package singleton

import (
    "fmt"
)

type tHungrySingleton struct {}

func newHungrySingleton() *tHungrySingleton {
    return &tHungrySingleton{}
}

func (me *tHungrySingleton) Hello() {
    fmt.Printf("tHungrySingleton.Hello\n")
}

var HungrySingleton IDemoSingleton = newHungrySingleton()

双重检查单例

DualCheckSingleton.go演示如何创建一个双重检查单例

package singleton

import (
    "fmt"
    "sync"
)

type tDualCheckSingleton struct {}


func newDualCheckSingleton() *tDualCheckSingleton {
    return &tDualCheckSingleton{}
}


func (me *tDualCheckSingleton) Hello() {
    fmt.Printf("tDualCheckSingleton.Hello\n")
}

var gDualCheckSingleton IDemoSingleton = nil
var gSingletonLock = new(sync.Mutex)

func GetDualCheckSingleton() IDemoSingleton {
    if gDualCheckSingleton == nil {
        gSingletonLock.Lock()
        defer gSingletonLock.Unlock()

        if gDualCheckSingleton == nil {
            gDualCheckSingleton = newDualCheckSingleton()
        }
    }

    return gDualCheckSingleton
}

容器式单例

ContainedSingleton.go演示如何通过Bean容器持有大量Bean单例. Bean容器本身是一个饿汉式单例.

package singleton

import (
    "errors"
    "fmt"
    "sync"
)

type IBeanContainer interface {
    GetBean(string) (bool, interface{})
    SetBean(string, interface{}) error
}

type tBeanContainer struct {
    mBeans map[string]interface{}
    mRWMutex *sync.RWMutex
}

func newBeanContainer() *tBeanContainer {
    return &tBeanContainer{
        mBeans: make(map[string]interface{}, 16),
        mRWMutex: new(sync.RWMutex),
    }
}

func (me *tBeanContainer) GetBean(name string) (bool, interface{}) {
    me.mRWMutex.RLock()
    defer me.mRWMutex.RUnlock()

    it, ok := me.mBeans[name]
    if ok {
        return true, it
    } else {
        return false, nil
    }
}

func (me *tBeanContainer) SetBean(name string, it interface{}) error {
    me.mRWMutex.Lock()
    defer me.mRWMutex.Unlock()

    if _,ok := me.mBeans[name];ok {
        return errors.New(fmt.Sprintf("bean with name %s already exists", name))
    }
    
    me.mBeans[name] = it
    return nil
}

type tContainedSingleton struct {}

func (me *tContainedSingleton) Hello() {
    fmt.Printf("tContainedSingleton.Hello\n")
}

func newContainedSingleton() IDemoSingleton {
    return &tContainedSingleton{}
}


var DefaultBeanContaibner = newBeanContainer()

func init() {
    DefaultBeanContaibner.SetBean("IDemoSingleton", newContainedSingleton())
}

单例模式小结

单例模式的优点
(1)单例模式可以保证内存里只有一个实例,减少了内存的开销。
(2)可以避免对资源的多重占用。
(3)单例模式设置全局访问点,可以优化和共享资源的访问。
单例模式的缺点
(1)单例模式一般没有接口,扩展困难。如果要扩展,则除了修改原来的代码,没有第二种途径,违背开闭原则。
(2)在并发测试中,单例模式不利于代码调试。在调试过程中,如果单例中的代码没有执行完,也不能模拟生成一个新的对象。
(3)单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则。

(end)

阅读 595

想当将军 首先要肯打

42 声望
17 粉丝
0 条评论

想当将军 首先要肯打

42 声望
17 粉丝
文章目录
宣传栏