范例网站怎么做人力资源培训

package singletontype singleton struct {
}var instance *singletonfunc GetInstance() *singleton {if instance == nil {instance = &singleton{}   // <---非线程安全的
    }return instance
}

var mu Sync.Mutexfunc GetInstance() *singleton {mu.Lock()                    // <--- 如果实例已经被创建就没有必要锁写
    defer mu.Unlock()if instance == nil {instance = &singleton{}}return instance
}

if check() {lock() {if check() {// perform your lock-safe code here
        }}
}

func GetInstance() *singleton {if instance == nil {     // <-- 不够完善. 他并不是完全的原子性
        mu.Lock()defer mu.Unlock()if instance == nil {instance = &singleton{}}}return instance
}

import "sync"
import "sync/atomic"var initialized uint32
...func GetInstance() *singleton {if atomic.LoadUInt32(&initialized) == 1 {return instance}mu.Lock()defer mu.Unlock()if initialized == 0 {instance = &singleton{}atomic.StoreUint32(&initialized, 1)}return instance
}

// Once is an object that will perform exactly one action.
type Once struct {m    Mutexdone uint32
}// Do calls the function f if and only if Do is being called for the
// first time for this instance of Once. In other words, given
//     var once Once
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation.  A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once.  Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
//     config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
//
func (o *Once) Do(f func()) {if atomic.LoadUint32(&o.done) == 1 { // <-- Checkreturn}// Slow-path.o.m.Lock()                           // <-- Lock
    defer o.m.Unlock()if o.done == 0 {                     // <-- Checkdefer atomic.StoreUint32(&o.done, 1)f()}
}

once.Do(func() {// 执行安全的初始化操作
})

package singletonimport ("sync"
)type singleton struct {
}var instance *singleton
var once sync.Oncefunc GetInstance() *singleton {once.Do(func() {instance = &singleton{}})return instance
}