最简单的一种，懒汉模式（非并发）

  1. package main
  3. import "fmt"
  5. var instance *single
  7. type single struct {
  8.     Name string
  9. }
  11. func GetInstance() *single {
  12.     if instance == nil {
  13.         instance = &single{}
  14.     }
  15.     return instance
  16. }
  17. func main() {
  18.     a := GetInstance()
  19.     a.Name = "a"
  20.     b := GetInstance()
  21.     b.Name = "b"
  23.     //0xc0000761d0 &{b}
  24.     //0xc0000761d0 &{b}
  25.     //0xc0000761d0 *main.single
  26.     //0xc0000761d0 *main.single
  28.     fmt.Println(&a.Name, a)
  29.     fmt.Println(&b.Name, b)
  30.     fmt.Printf("%p %T\n", a, a)
  31.     fmt.Printf("%p %T\n", b, b)
  32. }

懒汉模式加锁

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. var instance *single
  9. var lock sync.Mutex
  11. type single struct {
  12.     Name string
  13. }
  15. func GetInstance() *single {
  16.     lock.Lock()
  17.     defer lock.Unlock()
  18.     if instance == nil {
  19.         instance = &single{}
  20.     }
  21.     return instance
  22. }
  24. func main() {
  25.     a := GetInstance()
  26.     a.Name = "a"
  27.     b := GetInstance()
  28.     b.Name = "b"
  30.     //0xc0000101f0 &{b}
  31.     //0xc0000101f0 &{b}
  32.     //0xc0000101f0 *main.single
  33.     //0xc0000101f0 *main.single
  35.     fmt.Println(&a.Name, a)
  36.     fmt.Println(&b.Name, b)
  37.     fmt.Printf("%p %T\n", a, a)
  38.     fmt.Printf("%p %T\n", b, b)
  39. }

双重锁机制

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. var instance *single
  9. var lock sync.Mutex
  11. type single struct {
  12.     Name string
  13. }
  15. func GetInstance() *single {
  16.     if instance == nil {
  17.         lock.Lock()
  18.         defer lock.Unlock()
  19.         if instance == nil {
  20.             instance = &single{}
  21.         }
  22.     }
  23.     return instance
  24. }
  26. func main() {
  27.     a := GetInstance()
  28.     a.Name = "a"
  29.     b := GetInstance()
  30.     b.Name = "b"
  32.     //0xc000098040 &{b}
  33.     //0xc000098040 &{b}
  34.     //0xc000098040 *main.single
  35.     //0xc000098040 *main.single
  37.     fmt.Println(&a.Name, a)
  38.     fmt.Println(&b.Name, b)
  39.     fmt.Printf("%p %T\n", a, a)
  40.     fmt.Printf("%p %T\n", b, b)
  41. }

go语言自带一个很优雅的写法

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. var instance *single
  9. var once sync.Once
  11. type single struct {
  12.     Name string
  13. }
  15. func GetInstance() *single {
  16.     once.Do(func() {
  17.         instance = &single{}
  18.     })
  19.     return instance
  20. }
  22. func main() {
  23.     a := GetInstance()
  24.     a.Name = "a"
  25.     b := GetInstance()
  26.     b.Name = "b"
  28.     //0xc0000741e0 &{b}
  29.     //0xc0000741e0 &{b}
  30.     //0xc0000741e0 *main.single
  31.     //0xc0000741e0 *main.single
  33.     fmt.Println(&a.Name, a)
  34.     fmt.Println(&b.Name, b)
  35.     fmt.Printf("%p %T\n", a, a)
  36.     fmt.Printf("%p %T\n", b, b)
  37. }

Go打印

  1. %v 按值的本来值输出
  2. %+v 在 %v 基础上，对结构体字段名和值进行展开
  3. %#v 输出 Go 语言语法格式的值
  4. %T 输出 Go 语言语法格式的类型和值
  5. %% 输出 % 本体
  6. %b 整型以二进制方式显示
  7. %o 整型以八进制方式显示
  8. %d 整型以十进制方式显示
  9. %x 整型以十六进制方式显示
  10. %X 整型以十六进制、字母大写方式显示
  11. %U Unicode 字符
  12. %f 浮点数
  13. %p 指针，十六进制方式显示