[01] Go 디자인 모델: 단일 모드 (Singleton)

목차

단일 모드

1. 안내

2. 코드 실현

1. 게으름뱅이 모드

2. 굶 주 린 남자 모델

3. 개량 형 게으름뱅이 모델

4. sync. once 실현

5. 테스트 사례

단일 모드
프로필
단일 모델 (Singleton Pattern) 은 소프트웨어 디자인 에서 가장 간단 한 디자인 모델 중 하나 이다.이런 유형의 디자인 모델 은 창설 형 모델 에 속 하 는데, 이것 은 창설 대상 을 만 드 는 가장 좋 은 방법 을 제공한다.
이 모델 은 하나의 단일 클래스 와 관련 되 는데 이 클래스 는 자신의 대상 을 만 드 는 것 을 책임 지고 하나의 대상 만 생 성 되 는 것 을 확보한다.이 종 류 는 유일한 대상 을 방문 하 는 방식 을 제공 하여 직접 방문 할 수 있 으 며, 이러한 대상 을 예화 할 필요 가 없다.
주의:

1. 사례 류 는 하나의 사례 만 있 을 수 있다.

2. 단일 클래스 는 자신의 유일한 인 스 턴 스 를 만들어 야 합 니 다.

3. 단일 사례 류 는 모든 다른 대상 에 게 이 인 스 턴 스 를 제공 해 야 한다.

코드 구현
1. 게으름뱅이 모드
비 스 레 드 안전.만 들 고 있 을 때 Lazy Instance = nil 에 접근 하 는 스 레 드 가 있 습 니 다. 단일 클래스 에 여러 개의 인 스 턴 스 가 있 습 니 다.

var LazyInstance *Instance

func GetLazyInstance() *Instance {
    if LazyInstance == nil {
        LazyInstance = &Instance{
            Counter: 0,
            Name:    "LazyInstance",
        }
    }
    return LazyInstance
}

2. 굶 주 린 남자 모델
초기 화 에 시간 이 걸 리 면 성능 이 느 립 니 다.

var HungryInstance = &Instance{Name: "HungryInstance", Counter: 0}
func GetHungryInstance() *Instance {
    return HungryInstance
}

3. 개량 형 게으름뱅이 모델
읽 을 때마다 자 물 쇠 를 채 우 는 것 이 좋 습 니 다. 더 많은 경우 자 물 쇠 를 채 우지 않 아 도 됩 니 다.

var mu sync.Mutex
var LazyInstancePlus *Instance
func GetLazyInstancePlus() *Instance {
    mu.Lock()
    defer mu.Unlock()
    if LazyInstancePlus == nil {
        LazyInstancePlus = &Instance{
            Counter: 0,
            Name:    "LazyInstancePlus",
        }
    }
    return LazyInstancePlus
}

비 었 을 때 만 자 물 쇠 를 채 워 성능 을 향상 시 켰 다.

var LazyInsPlusPlus *Instance

func GetLazyInsPlusPlus() *Instance {
    if LazyInsPlusPlus == nil {
        mu.Lock()
        defer mu.Unlock()
        LazyInsPlusPlus = &Instance{
            Counter: 0,
            Name:    "LazyInsPlusPlus",
        }
    }
    return LazyInsPlusPlus
}

4. sync. once 실현

var once sync.Once
var SyncOnceInstance *Instance

func GetInstanceSyncOnce() *Instance {
    once.Do(func() {
        SyncOnceInstance = &Instance{
            Counter: 0,
            Name:    "SyncOnceInstance",
        }
    })
    return SyncOnceInstance
}

5. 테스트 사례

package main

import (
    "fmt"
    "sync"
)

type Instance struct {
    Name    string
    Counter int //    
}

func (i *Instance) Hello() {
    fmt.Printf("%s: my current counter is:%d
", i.Name, i.Counter)
}

//    
func main() {
    //      
    ls := GetLazyInstance()
    ls.Hello()
    ls.Counter += 1
    ls1 := GetLazyInstance()
    ls1.Hello()

    //      
    hs := GetHungryInstance()
    hs.Hello()
    hs.Counter += 10
    hs1 := GetHungryInstance()
    hs1.Hello()

    //       
    lsp := GetLazyInstancePlus()
    lsp.Hello()
    lsp.Counter += 100
    lsp1 := GetLazyInstancePlus()
    lsp1.Hello()

    lspp := GetLazyInsPlusPlus()
    lspp.Hello()
    lspp.Counter += 1000
    lspp1 := GetLazyInsPlusPlus()
    lspp1.Hello()

    //sync once   
    sc := GetInstanceSyncOnce()
    sc.Hello()
    sc.Counter += 10000
    sc1 := GetInstanceSyncOnce()
    sc1.Hello()

}

결과:

LazyInstance: my current counter is:0
LazyInstance: my current counter is:1
HungryInstance: my current counter is:0
HungryInstance: my current counter is:10
LazyInstancePlus: my current counter is:0
LazyInstancePlus: my current counter is:100
LazyInsPlusPlus: my current counter is:0
LazyInsPlusPlus: my current counter is:1000
SyncOnceInstance: my current counter is:0
SyncOnceInstance: my current counter is:10000

전체 코드 와 테스트 용례:https://gitee.com/ncuzhangben/GoStudy/tree/master/go-design-pattern/01-Singleton