区区一个单例就想阻止我拿大厂offer？-蒲公英云

超超为了能让婷婷过上幸福美满的生活，决定去大厂历练一番，下面是他去大厂面试时遇到的几个关于单例的问题。

认识单例

超超：您好，面试官~

面试官：你好，你平时开发是用 windows 还是 linux 居多？

超超：￣□￣｜｜我平时都是用windows开发的。

面试官：那你知道 windows 的资源管理器只能单开，但是cmd命令行可以开很多个，有想过这是为什么吗？

考点：单例的使用场景优缺点

超超：资源管理器在整个系统运行过程中不会因为不同的任务管理器内容改变而改变，因此为了节省资源全局只需要有一份，这是单例。

单例怎么用

#

面试官：你刚才说到了单例，你知道go里面怎么使用单例吗？

考点：go如何使用单例

超超：(￣▽￣)／这个简单，举个例子，婷婷在购物时，android端和web端只有一个指向用户婷婷的对象

1package main
 2
 3import (
 4    "fmt"
 5    "sync"
 6)
 7
 8//婷婷的淘宝客户端和web端都会指向婷婷这一个人
 9type Woman struct {
10    name string
11}
12
13var (
14    once sync.Once
15    ting *Woman
16)
17
18func getTing() *Woman {
19    once.Do(func() {
20        ting = new(Woman)
21        ting.name = "tingting"
22        fmt.Println("newtingting")
23    })
24    fmt.Println("gettingting")
25    return ting
26}
27
28func main() {
29    for i := 0; i < 3; i++ {
30        _ = getTing()
31    }
32}

结果

1newtingting
2gettingting
3gettingting
4gettingting

源码实现

面试官：那你能说说sync.Once是怎么实现的吗（：举个例子还秀起来了

考点：深入源码，进一步了解**Once**

超超：sync.Once是由Once结构体和其Do，doSlow俩个方法实现的

1type Once struct {
2    // done indicates whether the action has been performed.
3    // It is first in the struct because it is used in the hot path.
4    // The hot path is inlined at every call site.
5    // Placing done first allows more compact instructions on some architectures (amd64/x86),
6    // and fewer instructions (to calculate offset) on other architectures.
7    done uint32
8    m    Mutex
9}

done是标识位，用来判断方法f是否被执行完，其初始值为0，当f执行结束时，done被设为1。

m做竞态控制，当f第一次执行还未结束时，通过m加锁的方式阻塞其他once.Do执行f。

这里有个地方需要特别注意下，once.Do是不可以嵌套使用的，嵌套使用将导致死锁。

1func (o *Once) Do(f func()) {
 2    // Note: Here is an incorrect implementation of Do:
 3    //
 4    //  if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
 5    //      f()
 6    //  }
 7    //
 8    // Do guarantees that when it returns, f has finished.
 9    // This implementation would not implement that guarantee:
10    // given two simultaneous calls, the winner of the cas would
11    // call f, and the second would return immediately, without
12    // waiting for the first's call to f to complete.
13    // This is why the slow path falls back to a mutex, and why
14    // the atomic.StoreUint32 must be delayed until after f returns.
15
16    if atomic.LoadUint32(&o.done) == 0 {
17        // Outlined slow-path to allow inlining of the fast-path.
18        o.doSlow(f)
19    }
20}
21
22func (o *Once) doSlow(f func()) {
23    o.m.Lock()
24    defer o.m.Unlock()
25    if o.done == 0 {
26        defer atomic.StoreUint32(&o.done, 1)
27        f()
28    }
29}