为什么 Gosync.Map 在实现上存在差异或者我有错觉？

哈喽！今天心血来潮给大家带来了《为什么 Gosync.Map 在实现上存在差异或者我有错觉？》，想必大家应该对Golang都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习Golang，千万别错过这篇文章~希望能帮助到你！

sync.map 是并发安全地图实现。 sync.map 中原始地图的类型实际上是 map[any]*entry。

当我们调用map.loadorstore并且条目存在时，会调用entry.tryloadorstore，以下是该函数的代码

func (e *entry) tryloadorstore(i any) (actual any, loaded, ok bool) {
    p := e.p.load()
    if p == expunged {
        return nil, false, false
    }
    if p != nil {
        return *p, true, true
    }

    // copy the interface after the first load to make this method more amenable
    // to escape analysis: if we hit the "load" path or the entry is expunged, we
    // shouldn't bother heap-allocating.
    ic := i
    for {
        if e.p.compareandswap(nil, &ic) {
            return i, false, true
        }
        p = e.p.load()
        if p == expunged {
            return nil, false, false
        }
        if p != nil {
            return *p, true, true
        }
    }
}

这是另一个函数tryswap，当我们调用swap或store时，也会调用这个函数。

func (e *entry) tryswap(i *any) (*any, bool) {
    for {
        p := e.p.load()
        if p == expunged {
            return nil, false
        }
        if e.p.compareandswap(p, i) {
            return p, true
        }
    }
}

tryloadorstore 可以像 tryswap 一样仅基于其逻辑来实现，但事实并非如此。我的问题是：既然它们的逻辑相似，为什么它们的实现方式不同？

当我尝试理解时，我认为这是因为参数类型的差异，如果 i 是 *any，则不需要进行复制，因为它已经是一个指针，我们不需要关心转义分析。但似乎没有什么特殊原因需要从外部调用者那里获取地址。

    if e, ok := read.m[key]; ok {
        if v, ok := e.trySwap(&value); ok {
            if v == nil {
                return nil, false
            }
            return *v, true
        }
    }

然后我不知道为什么这两个函数（以及其他函数）以不同的方式实现。

正确答案

首先，a quote，来自 bryan mills，sync.map 的原作者：

sync.map 一开始就非常粗糙！

sync.map中的代码对逃逸分析非常敏感，并且实现由基准测试驱动。

让我们深入研究一下提交历史记录。它应该可以帮助我们理解为什么它们以不同的方式实现。

CL 37342的初步实现：

1. first patchset 中的实施草案类似：

func (e *entry) trystore(i interface{}) bool {
    for {
        p := atomic.loadpointer(&e.p)
        if p == expunged {
            return false
        }
        if atomic.compareandswappointer(&e.p, p, unsafe.pointer(&i)) {
            return true
        }
    }
}

func (e *entry) tryloadorstore(i interface{}) (actual interface{}, loaded, clean bool) {
    for {
        p := atomic.loadpointer(&e.p)
        if p == expunged {
            return nil, false, false
        }
        if p != nil {
            return *(*interface{})(p), true, true
        }
        if atomic.compareandswappointer(&e.p, nil, unsafe.pointer(&i)) {
            return i, false, true
        }
    }
}

1. 接口复制技巧已添加到 patchset 3 中的两个实现中：

// copy the interface to make this method more amenable to escape analysis:
// if we hit the "load" path or the entry is expunged, we shouldn't bother
// heap-allocating.
ic := i

1. (*entry).trystore 被修改为接受 patchset 5 中的指针：

我找不到对此更改的评论。这很可能是逃逸分析和基准测试的结果。

func (e *entry) trystore(i *interface{}) bool {
    p := atomic.loadpointer(&e.p)
    if p == expunged {
        return false
    }
    for {
        if atomic.compareandswappointer(&e.p, p, unsafe.pointer(i)) {
            return true
        }
        p = atomic.loadpointer(&e.p)
        if p == expunged {
            return false
        }
    }
}

func (e *entry) tryloadorstore(i interface{}) (actual interface{}, loaded, ok bool) {
    p := atomic.loadpointer(&e.p)
    if p == expunged {
        return nil, false, false
    }
    if p != nil {
        return *(*interface{})(p), true, true
    }

    // copy the interface after the first load to make this method more amenable
    // to escape analysis: if we hit the "load" path or the entry is expunged, we
    // shouldn't bother heap-allocating.
    ic := i
    for {
        if atomic.compareandswappointer(&e.p, nil, unsafe.pointer(&ic)) {
            return i, false, true
        }
        p = atomic.loadpointer(&e.p)
        if p == expunged {
            return nil, false, false
        }
        if p != nil {
            return *(*interface{})(p), true, true
        }
    }
}

(*entry).trystore 在 CL 137441 中得到简化：

此更改可防止这种逃逸到堆的情况：

sync/map.go:178:26: &e.p escapes to heap
sync/map.go:178:26:     from &e.p (passed to call[argument escapes]) at

func (e *entry) trystore(i *interface{}) bool {
    for {
        p := atomic.loadpointer(&e.p)
        if p == expunged {
            return false
        }
        if atomic.compareandswappointer(&e.p, p, unsafe.pointer(i)) {
            return true
        }
    }
}

(*entry).trystore 在 CL 399094 中重命名为 (*entry).tryswap：

func (e *entry) trySwap(i *any) (*any, bool) {
   for {
       p := e.p.Load()
       if p == expunged {
           return nil, false
       }
       if e.p.CompareAndSwap(p, i) {
           return p, true
       }
   }
}

仅此而已。

注意：其他一些小型 cl 未列出，例如将实现切换为使用 atomic.pointer 的 CL 426074。

今天关于《为什么 Gosync.Map 在实现上存在差异或者我有错觉？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！