-2

我阅读了这篇文章并决定自己重复这种行为并进行实验：

package main

import (
    "fmt"
    "time"
)

type User struct {
    i    int
    token string
}

func NewUser(i int, token string) User {
    user := User{token: fmt.Sprint(i), i: i}
    return user
}

func (u *User) PrintAddr() {
    fmt.Printf("%d (PrintAddr): %p\n", u.i, u)
}

func main() {
    users := make([]User, 4)
    for i := 0; i < 4; i++ {
        user := NewUser(i, "")
        users[i] = user
    }
    
    for i, user := range users {
        go user.PrintAddr()
        go users[i].PrintAddr()
    }
    time.Sleep(time.Second)
}

（游乐场）

这是代码输出：

1 (PrintAddr): 0xc000056198
2 (PrintAddr): 0xc0000561b0
0 (PrintAddr): 0xc000056180
3 (PrintAddr): 0xc00000c030
3 (PrintAddr): 0xc00000c030
3 (PrintAddr): 0xc00000c030
3 (PrintAddr): 0xc00000c030
3 (PrintAddr): 0xc0000561c8

我也不明白，为什么 4 of 5 3 (PrintAddr)are 0xc00000c030，最后一个不一样？

但是，如果我使用指针数组而不是值数组，像这样，

func NewUser(i int, token string) *User {
    user := &User{token: fmt.Sprint(i), i: i}
    return user
}
// -snip-
func main() {
    users := make([]*User, 4)
    // -snip-

（游乐场）

那么这里一切都很好，每个条目都用相同的地址打印了 2 次：

1 (PrintAddr): 0xc0000ae030
3 (PrintAddr): 0xc0000ae060
2 (PrintAddr): 0xc0000ae048
2 (PrintAddr): 0xc0000ae048
3 (PrintAddr): 0xc0000ae060
1 (PrintAddr): 0xc0000ae030
0 (PrintAddr): 0xc0000ae018
0 (PrintAddr): 0xc0000ae018

但是为什么文章中的情况不适用于这里，而我没有得到很多3 (PrintAddr)呢？

4

2 回答 2

3

问题

您的第一个版本有一个同步错误，表现为数据竞争：

$ go run -race main.go
0 (PrintAddr): 0xc0000b4018
0 (PrintAddr): 0xc0000c2120
==================
WARNING: DATA RACE
Write at 0x00c0000b4018 by main goroutine:
  main.main()
      redacted/main.go:29 +0x1e5

Previous read at 0x00c0000b4018 by goroutine 7:
  main.(*User).PrintAddr()
      redacted/main.go:19 +0x44

Goroutine 7 (finished) created at:
  main.main()
      redacted/main.go:30 +0x244
==================
1 (PrintAddr): 0xc0000b4018
1 (PrintAddr): 0xc0000c2138
2 (PrintAddr): 0xc0000b4018
2 (PrintAddr): 0xc0000c2150
3 (PrintAddr): 0xc0000b4018
3 (PrintAddr): 0xc0000c2168
Found 1 data race(s)

循环（第for29 行）不断更新循环变量user ，同时（即以没有适当同步的并发方式）该PrintAddr方法通过其指针接收器访问它（第 19 行）。请注意，如果您在第 30 行不user.PrintAddr()作为 goroutine 开始，问题就会消失。

问题及其解决方案实际上在您链接到的 Wiki底部给出。

但是为什么文章中的情况不适用于这里，而我没有得到很多3 (PrintAddr)呢？

该同步错误是不受欢迎的不确定性的来源。特别是，您无法预测3 (PrintAddr)将打印多少次（如果有），并且该数字可能会因一次执行而异。事实上，向上滚动并亲自查看：在我打开竞赛检测器的执行过程中，输出碰巧具有两个介于 0 和 3 之间的整数，尽管存在错误；但不能保证。

解决方案

user只需在循环顶部隐藏循环变量，问题就会消失：

for i, user := range users {
    user := user // <---
    go user.PrintAddr()
    go users[i].PrintAddr()
}

PrintAddr现在将对最里面的user变量进行操作，for第 29 行的循环不会更新该变量。

（游乐场）

附录

您还应该使用等待组来等待所有 goroutine 完成。time.Sleep是没有办法协调 goroutines 的。

于 2021-07-18T13:08:08.167 回答
2

跨越值切片的代码的第一个版本获取迭代器变量的地址。. 为什么？

该方法PrintAddr在指针接收器上定义：

func (u *User) PrintAddr() {
    fmt.Printf("%d (PrintAddr): %p\n", u.i, u)
}

在 for 循环中，user迭代变量在每个循环中重复使用，并在切片中分配下一个值。因此它是同一个变量。但是您通过调用在指针接收器上定义的方法来获取它的地址：

    users := make([]User, 4)
    // ...
    for i, user := range users {
        go user.PrintAddr()
        go users[i].PrintAddr()
    }

对值调用方法等于(&user).PrintAddr()：

Ifx是可寻址的并且 &x 的方法集包含m,x.m()是简写(&x).m()

相反，索引切片按预期工作，因为您正在访问i切片中的实际 -th 值，而不是使用迭代器 var。

更改切片以保存指针值也可以解决此问题，因为迭代器 var 现在是指向该User值的指针的副本。

于 2021-07-18T11:23:47.837 回答