Is it thread safe to concurrently read/access an array in go?-CodePudding

Like if I have a struct with an array and I want to do something like this

type Paxos struct {
    peers      []string
}

for _, peer := range px.peers {
   \\do stuff
}

My routines/threads will never modify the peers array, just read from it. Peers is an array of server addresses, and servers may fail but that wouldn't affect the peers array (later rpc calls would just fail)

CodePudding user response：

If no writes are involved, concurrent reads are always safe, regardless of the data structure. However, as soon as even a single concurrency-unsafe write to a variable is involved, you need to serialise concurrent access (both writes and reads) to the variable.

Moreover, you can safely write to elements of a slice or an array under the condition that no more than one goroutine write to a given element.

For instance, if you run the following programme with the race detector on, it's likely to report a race condition, because multiple goroutines concurrently modify variable results without precautions:

package main

import (
    "fmt"
    "sync"
)

func main() {
    const n = 8
    var results []int
    var wg sync.WaitGroup
    wg.Add(n)
    for i := 0; i < n; i   {
        i := i
        go func() {
            defer wg.Done()
            results = append(results, square(i))
        }()
    }
    wg.Wait()
    fmt.Println(results)

}

func square(i int) int {
    return i * i
}

However, the following programme contains no such no synchronization bug, because each element of the slice is modified by a single goroutine:

package main

import (
    "fmt"
    "sync"
)

func main() {
    const n = 8
    results := make([]int, n)
    var wg sync.WaitGroup
    wg.Add(n)
    for i := 0; i < n; i   {
        i := i
        go func() {
            defer wg.Done()
            results[i] = square(i)
        }()
    }
    wg.Wait()
    fmt.Println(results)

}

func square(i int) int {
    return i * i
}

CodePudding user response：

Yes, reads are thread-safe in Go and virtually all other languages. You're just looking up an address in memory and seeing what is there. If nothing is attempting to modify that memory, then you can have as many concurrent reads as you'd like.