multithreading - go指针多线程读写错误

Question

正常应该是恒定输出

test1
test2
........

但是只有test1输出，程序挂了，没有任何反应指针的赋值是最基本的操作，这个应该是线程安全的，满足句号但是这个测试没能

type Point struct {
    X int
    Y int
}

func main() {
    var p *Point = nil
    test := true
    go func() {
        for test {
            if tmp := p; tmp == nil {
                p = &Point{}
            }
        }
    }()
    go func() {
        for test {
            if tmp := p; tmp != nil {
                p = nil
            }
        }
    }()

    n := 0
    for test {
        n++
        fmt.Printf("testing%v....\r\n",n)
        time.Sleep(1000 * time.Millisecond)
    }

    fmt.Printf("test fail")
}

代码: https://play.golang.org/p/-NTq-2iyX5W

如果把指针改成int，这很好

func main() {
    var p int = 0
    test := true
    go func() {
        for test {
            if tmp := p; tmp == 0 {
                p = 1
            }
        }
    }()
    go func() {
        for test {
            if tmp := p; tmp != 0 {
                p = 0
            }
        }
    }()

    n := 0
    for test {
        n++
        fmt.Printf("testing%v....\r\n",n)
        time.Sleep(1000 * time.Millisecond)
    }

    fmt.Printf("test fail")
}

Answer 1

问题不仅在于有一场比赛，还在于有一场比赛时日程安排会出现问题。下面的代码有一些选项可以使这段代码产生所需的输出(它被注释掉了)。所以你要么:

1. 添加一个锁来修复竞争条件[正确的方式]

或

1. 为每个赛车程序添加一个小 sleep - 比赛继续存在

这段代码

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

type Point struct {
    X int
    Y int
}

var lock sync.Mutex

func main() {
    // runtime.GOMAXPROCS(4)
    fmt.Println("Max # of parallel processes = ", MaxParallelism())

    var p *Point = nil
    test := true
    go func() {
        for test {
            // lock.Lock()
            if tmp := p; tmp == nil {
                p = &Point{}
            }
            // lock.Unlock()
            // time.Sleep(1 * time.Nanosecond)

        }
    }()
    go func() {
        for test {
            // lock.Lock()
            if tmp := p; tmp != nil {
                p = nil
            }
            // lock.Unlock()
            // time.Sleep(1 * time.Nanosecond)
        }
    }()

    n := 0
    for test {
        n++
        fmt.Printf("testing%v....\r\n", n)
        time.Sleep(1000 * time.Millisecond)
    }

    fmt.Printf("test fail")
}

func MaxParallelism() int {
    maxProcs := runtime.GOMAXPROCS(0)
    numCPU := runtime.NumCPU()
    if maxProcs < numCPU {
        return maxProcs
    }
    return numCPU
}

输出(在我的机器上。请注意，为了可能的并行计算，goroutines 的数量应该等于或小于虚拟处理器的数量):

go run main.go 
Max # of parallel processes =  4
testing1....

尽管有 4 个虚拟处理器，但问题似乎是 main 在第一次 sleep 后永远不会被调度。显然，当存在竞争条件时，这会莫名其妙地(至少对我而言)养育它丑陋的头脑。另一个观察结果是，如果我们减少两个 goroutine 中的一个并继续修改 main 循环中的 p 变量，那么它就可以工作。所有这些似乎给人一种印象，即当存在竞争条件时，运行时处理的行为是不可预测的。