在 Golang 中使用互斥锁或互斥指针？

Question

我有一个代码sn-p：

type calculation struct{
    sum int
    mutex sync.Mutex
}

func dosomething(c *calculation , wg *sync.WaitGroup) {
    c.mutex.Lock()
    c.sum++
    c.mutex.Unlock()
    wg.Done()
}

func main() {
    t := time.Now()
    c := new(calculation)
    wg := new(sync.WaitGroup)
    for i:=0; i<10000000; i++{
        wg.Add(1)
        go dosomething(c, wg)
    }
    wg.Wait()
    fmt.Println(c.sum)
    fmt.Println(time.Since(t))
}

但我发现使用互斥指针也可以：

type calculation struct{
    sum int
    mutex *sync.Mutex
}

func dosomething(c *calculation , wg *sync.WaitGroup) {
    c.mutex.Lock()
    c.sum++
    c.mutex.Unlock()
    wg.Done()
}

func main() {
    t := time.Now()
    c := &calculation{0, new(sync.Mutex)}
    wg := new(sync.WaitGroup)
    for i:=0; i<10000000; i++{
        wg.Add(1)
        go dosomething(c, wg)
    }
    wg.Wait()
    fmt.Println(c.sum)
    fmt.Println(time.Since(t))
}

我对这两个版本做了一些测试，发现经过的时间很接近。

那么我应该使用哪一个？为什么我应该使用互斥体或互斥体指针？它们有性能差异吗？

Answer 1

Go sync.Mutex 不能被复制，所以当你有一个可以被合理复制的数据结构但它本身的某些部分是shared 并且不能被合理地复制，并且您计划通过值传递它和/或返回它，以便它被复制。

例如：

type Thingy struct {
    notShared int
    mtx *Sync.mutex
    shared *int
}

func (t Thingy) Thingy {
    t.notShared += 3
    t.mtx.Lock()
    *t.shared *= 2
    t.mtx.Unlock()
    return t
}

（可能更典型的是有多个非共享字段，然后一个指向struct 的指针，其中包含互斥体本身和共享字段。以上主要用于说明）

鉴于您的 calculation 结构本身始终作为指针传递，但没有理由为您的示例添加间接级别。

编辑：您添加了一个关于性能差异的问题。添加额外的（否则不必要的）间接通常会降低性能，但一般来说，您应该首先编写可读性最高的代码，然后针对性能问题对其进行测量。在我看来，添加额外的不必要的间接会使代码的可读性稍差一些，因此在这里，性能和可读性是相辅相成的。