go 单例模式

阅读更多

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

type singleton struct{}

var (
	instance *singleton
	initialized uint32
	mu sync.Mutex
)

func Instance() *singleton {
	if atomic.LoadUint32( &initialized ) ==1 {
		return instance
	}

	mu.Lock()
	defer mu.Unlock()

	if  instance==nil {
		atomic.StoreUint32(&initialized, 1)
		instance = new(singleton)
	}

	return instance
}

func main() {
	var test=Instance()
	fmt.Printf("test:%+v",*test)
}

type Once struct {
m Mutex
done uint32
}

func (o *Once) Do(f func()) {
     if atomic.LoadUint32(&o.done) == 1 {
     return
} 
o.m.Lock()
defer o.m.Unlock()
if o.done == 0 {
   defer atomic.StoreUint32(&o.done, 1)
   f()
   }
}

基于 sync.Once 重新实现单件模式：

var (
 instance *singleton
  once sync.Once
) 
func Instance() *singleton {
    once.Do(func() {
       instance = &singleton{}
     })
     return instance
}