在 Go sync.Map 中，为什么这部分实现不一致或者我误解了什么

弗里斯特，a quote岁，来自布莱恩·米尔斯，sync.Map的原始作者:

从一开始，sync.Map就相当粗糙了！

sync.Map中的代码对逸出分析非常敏感，实现由Benchmark驱动.

让我们深入研究提交历史.它应该有助于我们理解为什么它们以不同的方式实现.

The initial implementation in 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
        }
    }
}

2. 在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

3. (*entry).tryStore被修改为接受patchset 5中的指针:

我找不到对这一变化的 comments .这很可能是逃逸分析和基准测试的结果.

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 was simplified in 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 was renamed to (*entry).trySwap in CL 399094:

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
       }
   }
}

就这样.

Note:其他一些小的CLS没有列出，例如，将实现切换到使用atomic.Pointer的CL 426074.