data-race, two goroutines plus same val

Question

consider below code, in my opinon, val will between 100 and 200, but it's always 200

var val = 0

func main() {
    num := runtime.NumCPU()
    fmt.Println("使用cpu数量", num)
    go add("A")
    go add("B")
    time.Sleep(1 * time.Second)
    fmt.Println("val的最终结果", val)
}

func add(proc string) {
    for i := 0; i < 100; i++ {
        val++
        fmt.Printf("execute process[%s] and val is %d\n", proc, val)
        time.Sleep(5 * time.Millisecond)
    }
}

why val always is 200 at last?

in laptop, val may be 128 or other between 100 and 200. but in desktop computer, val is always 200 — space, Sep 14 '21 at 17:23
You have a data race. Any expectations on behavior are invalid. — Adrian, Sep 14 '21 at 17:23
val should between 100 and 200, but always 200 in my desktop computer — space, Sep 14 '21 at 17:39
`val` could be literally anything. Fix your data race before you worry about anything else. — Adrian, Sep 14 '21 at 17:42

score 1 · Accepted Answer · answered Sep 14 '21 at 18:07

There are 2 problems with your code:

You have a data race - concurrently writing and reading val without synchronization. The presence of it makes reasoning about program outcome meaningless.
The sleep in main() of 1 second is too short - the goroutines may not be done yet after 1 second. You expect fmt.Printf to take no time at all, but console output does take significant amount of time (on some OS longer than others). So the loop won't take 100 * 5 = 500 milliseconds, but much, much longer.

Here's a fixed version that atomically increments val and properly waits for both goroutines to finish instead of assuming that they will be done within 1 second.

var val = int32(0)

func main() {
    num := runtime.NumCPU()
    fmt.Println("使用cpu数量", num)
    var wg sync.WaitGroup
    wg.Add(2)
    go add("A", &wg)
    go add("B", &wg)
    wg.Wait()
    fmt.Println("val的最终结果", atomic.LoadInt32(&val))
}

func add(proc string, wg *sync.WaitGroup) {
    for i := 0; i < 100; i++ {
        tmp := atomic.AddInt32(&val, 1)
        fmt.Printf("execute process[%s] and val is %d\n", proc, tmp)
        time.Sleep(5 * time.Millisecond)
    }
    wg.Done()
}

Hymns For Disco · Answer 2 · 2021-09-14T17:49:32.157

Incrementing the integer will take only on the order of a few nanoseconds, while each goroutine is waiting 5 milliseconds between each increment.

Meaning, each goroutine is only spending about a 1,000,000th of the time actually doing the operation, the rest of the time is sleeping. Therefore, the likelihood of an interference happening is quite low (since both goroutines would need to be doing the operation simultaneously).

Even if both goroutines are on equal timers, the practical precision of the time library is nowhere near the nanosecond scale required to produce collisions consistently. Plus, the goroutines are doing some printing, which will further diverge the timings.

As pointed out in the comments, your code does still have a data race (as is your intention, seemingly), meaning that we cannot say anything for certain about the output of your program, despite any observations. It's possible that it would output any number from 100-200, or different numbers entirely.

data-race, two goroutines plus same val

2 Answers2