Why are different array lengths output in concurrent golang programming?

php Xiaobian Yuzai will answer the question of outputting different array lengths in concurrent golang programming. In concurrent programming, when multiple goroutines operate a shared resource at the same time, race conditions may occur, resulting in uncertain results. When multiple goroutines operate on arrays at the same time, the array lengths may be different. This is because the execution order between goroutines is uncertain, and read and write operations may occur at the same time, resulting in inconsistency in array lengths. To solve this problem, you can use mechanisms such as mutex locks or channels to ensure synchronization and sequential execution between goroutines, so as to obtain certain results.

Question content

I am writing a simple program in golang for concurrent testing, but I don’t understand the difference in capitalized each time array size Output!

data := []rune{'a', 'b', 'c', 'd'}
var capitalized []rune

capit := func(r rune) {
    capitalized = append(capitalized, unicode.toupper(r))
    fmt.printf("%c done!\n", r)
}

fmt.printf("before: %c\n", capitalized)
for i := 0; i < len(data); i++ {
    go capit(data[i])
}
time.sleep(100 * time.millisecond)
fmt.printf("after: %c\n", capitalized)

Output:

b done! a done! d done! c done! after: [d b c a]

a done! d done! c done! b done! after: [d b a]

d done! a done! c done! b done! after: [b]

d done! a done! c done! b done! after: [a b c]

d done! b done! a done! c done! After: [B C]

Solution

go: Data Race Detector

You have a data race.

$ go run -race racer.go
before: []
==================
warning: data race
write at 0x00c000012018 by goroutine 8:
  main.main.func1()
      racer.go:14 +0xc4
  main.main.func2()
      racer.go:20 +0x3e

previous read at 0x00c000012018 by goroutine 7:
  main.main.func1()
      racer.go:14 +0x44
  main.main.func2()
      racer.go:20 +0x3e

goroutine 8 (running) created at:
  main.main()
      racer.go:20 +0x199

goroutine 7 (running) created at:
  main.main()
      racer.go:20 +0x199
==================
a done!
==================
warning: data race
write at 0x00c000012018 by goroutine 9:
  main.main.func1()
      racer.go:14 +0xc4
  main.main.func2()
      racer.go:20 +0x3e

previous write at 0x00c000012018 by goroutine 10:
  main.main.func1()
      racer.go:14 +0xc4
  main.main.func2()
      racer.go:20 +0x3e

goroutine 9 (running) created at:
  main.main()
      racer.go:20 +0x199

goroutine 10 (running) created at:
  main.main()
      racer.go:20 +0x199
==================
d done!
b done!
c done!
after: [b c]
found 2 data race(s)
exit status 66
$

racer.go：

package main

import (
    "fmt"
    "time"
    "unicode"
)

func main() {
    data := []rune{'a', 'b', 'c', 'd'}
    var capitalized []rune

    capIt := func(r rune) {
        capitalized = append(capitalized, unicode.ToUpper(r))
        fmt.Printf("%c done!\n", r)
    }

    fmt.Printf("Before: %c\n", capitalized)
    for i := 0; i < len(data); i++ {
        go capIt(data[i])
    }
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("After: %c\n", capitalized)
}

The above is the detailed content of Why are different array lengths output in concurrent golang programming?. For more information, please follow other related articles on the PHP Chinese website!