在单独的goroutine中访问同一结构的不同字段是否需要互斥锁？

小伙伴们有没有觉得学习Golang很有意思？有意思就对了！今天就给大家带来《在单独的goroutine中访问同一结构的不同字段是否需要互斥锁？》，以下内容将会涉及到，若是在学习中对其中部分知识点有疑问，或许看了本文就能帮到你！

我有一个结构体，其中有几个简单的字段（即：int、string 和 []byte）。

我还有几个 goroutine 可以修改结构中的不同字段。但每个 goroutine 都会修改自己的字段。

我没有注意到任何问题或竞争条件的提示。然后我很容易地将sync.Mutex添加到代码中，并且代码运行得完全相同。

但从我读到的内容来看，似乎有些人可能建议在这种情况下使用sync.Mutex。即使程序运行没有错误，是否需要它？

解决方案

为了锁定的目的，将结构体的每个字段视为独立的。鉴于：

type foo struct {
    stringmap  map[string]string
    strings   []string
    numbers   []float64
}

以下内容是安全的：

foo := &foo{}
/* ... */
go func() {
    foo.stringmap["foo"] = "bar"
}()
go func() {
    foo.strings[0] = "baz"
}()
go func() {
    fmt.println(foo.numbers[0])
}()

但这不安全：

go func() {
    fmt.println(foo.numbers[0])
}()
go func() {
    foo.numbers = append(foo.numbers, 123.456)
}()

因此，您通常希望每个字段或可以一起修改的每组字段都有一个互斥锁：

type foo struct {
    stringmapmu sync.mutex
    stringmap   map[string]string
    stringsmu   sync.mutex
    strings     []string
    numbersmu   sync.mutex
    numbers     []float64
}

然后：

go func() {
    foo.numbersmu.lock()
    defer foo.numbersmu.unlock()
    fmt.println(foo.numbers[0])
}()
go func() {
    foo.numbersmu.lock()
    defer foo.numbersmu.unlock()
    foo.numbers = append(foo.numbers, 123.456)
}()

使用 flimzys 方法时必须非常小心！如果您想在同一个 goroutine 中使用结构的不同字段，并且不跟踪字段的阻塞顺序，则可能会陷入僵局。 https://play.golang.org/p/wbgs40UoP-h

相同的阻塞顺序可以正常工作

//the same order stringmapmu-->numbersmu
go func() {
    defer wg.done()
    foo.stringmapmu.lock()//lock on stringmap, waits unlocking numbersmu by other goroutine
    defer foo.stringmapmu.unlock()

    foo.numbersmu.lock()
    defer foo.numbersmu.unlock()

    fmt.println(foo.numbers, foo.stringmap)
}()

//works fine
//the same order stringmapmu-->numbersmu
go func() {
    defer wg.done()

    foo.stringmapmu.lock()//lock on stringmap, waits unlocking numbersmu by other goroutine
    defer foo.stringmapmu.unlock()

    foo.numbersmu.lock()
    defer foo.numbersmu.unlock()

    foo.numbers = append(foo.numbers, 123.456)
    foo.stringmap["foo"] = "bar"
}()

但是相反的顺序......陷入僵局

//reverse order numbersMu-->stringMapMu
go func() {
    foo.numbersMu.Lock()//lock on numbersMu, waits unlocking stringMapMu by other goroutine
    defer foo.numbersMu.Unlock()

    foo.stringMapMu.Lock()
    defer foo.stringMapMu.Unlock()

    foo.numbers = append(foo.numbers, 123.456)
    foo.stringMap["foo"]="bar"
}()

此外，各个字段的锁可以是隐式的，隐藏在“set”和“get”方法中。您将在 goroutine 中以不同的顺序操作它们，最终会出现死锁 = ( 如果不是性能问题，我更喜欢为您的结构使用单个互斥锁。

好了，本文到此结束，带大家了解了《在单独的goroutine中访问同一结构的不同字段是否需要互斥锁？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！