参考代码：

# 用装饰实现
def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper


@singleton
class Foo(object):
    pass
foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

# 用基类实现
class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

class Foo(Singleton):
    pass
foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

# 使用元类实现
class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

# Python2
class Foo(object):
    __metaclass__ = Singleton
# Python3
class Foo(metaclass=Singleton):
    pass

foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

package main

import (
    "fmt"
    "sync"
    "time"
)

// 定义结构体代替类
type singleton struct {
}

// 定义全局变量
var (
    instance *singleton
    lock     sync.Mutex
)

func GetSingleton()  *singleton{
    // 懒汉加锁方式：指全局的单例实例在第一次被使用时构建。
    if instance == nil { // 单例没被实例化，才会加锁
        lock.Lock()
        defer lock.Unlock() // return 之后释放锁
        if instance == nil { // 单例没被实例化才会创建
            instance = &singleton{}
        }
    }
    return instance
}

func main() {

    /*
    实现单例模式
    定义：单例对象的类必须保证只有一个实例存在，全局有唯一接口访问。
    https://github.com/silsuer/golang-design-patterns/blob/master/singleton/README.md
    */

    fmt.Printf("%p\n", GetSingleton())
    fmt.Printf("%p\n", GetSingleton())
    fmt.Printf("%p\n", GetSingleton())
    time.Sleep(time.Second)
    fmt.Println("done")

}