竞赛模拟致命错误：所有goroutine都处于休眠状态-死锁

我正在Golang建立一个护理模拟，我遇到了一个僵局问题。 Goroutines用于表示每个参赛者。 这个想法是，一旦一个赛车手达到了目标，一个渠道是用来沟通谁赢得了比赛。 有人能发现我的错误吗

package main

import (
    "fmt"
    "math/rand"
    "strconv"
    "sync"
    "time"
)

var wg sync.WaitGroup
var counter Counter
var tracks Tracks
var winner chan int

func newCounter(size int) Counter {
    return Counter{racers: make([]int, size+1)} // not using the zero'th index
}

func newTracks(size int) Tracks {
    return Tracks{racers: make([]string, size+1)}
}

func incrementCounter(n int) {
    counter.racers[n]++
}

func equalCounter() bool {
    rv := true
    for i, _ := range counter.racers {
        if counter.racers[0] != counter.racers[i] {
            rv = false
            break
        }
    }
    return rv
}

func smallerCounter(racerNumber int) bool {
    var rv bool
    for v := range counter.racers {
        if counter.racers[racerNumber] < v {
            rv = true
        } else {
            rv = false
        }
    }

    return rv
}

func checkCounter(racerNumber int) bool {
    var rv bool
    if equalCounter() || smallerCounter(racerNumber) {
        rv = true
    } else {
        rv = false
    }

    return rv
}

func racer(racerNum int) {
    steps := rand.Intn(5) + 1
    distance := 0
    goal := 100
    if checkCounter(racerNum) {
        for j := distance; distance < goal; j++ {
            for i := 0; i < steps; i++ {
                tracks.racers[racerNum] += "x"
            }
            distance += steps
            duration := rand.Int31n(200)
            time.Sleep(time.Duration(duration) * time.Millisecond)
            fmt.Println(tracks.racers[racerNum] + "[" + strconv.Itoa(racerNum) + "]")
        }

        incrementCounter(racerNum)
    }

    if distance >= goal {
        winner <- racerNum
        close(winner)
    }

    wg.Done()
}

func main() {
    racers := 5
    counter = newCounter(racers)
    tracks = newTracks(racers)

    for i := 1; i <= racers; i++ {
        wg.Add(1)
        go racer(i)
    }

    wg.Wait()

    fmt.Print("Winner is:")
    fmt.Print(<-winner)
}


type Counter struct {
    racers []int
}

type Tracks struct {
    racers []string
}

主程序包
进口(
“fmt”
“数学/兰德”
“strconv”
“同步”
“时间”
)
var wg sync.WaitGroup
var计数器
变量跟踪
var winner chan int
func新计数器（整型大小）计数器{
返回计数器{racers:make（[]int，size+1）}//不使用第0个索引
}
func新轨道（整型尺寸）轨道{
返回轨道{racers:make（[]字符串，大小+1）}
}
func递增计数器（n int）{
柜台.赛车手[n]++
}
func equalCounter（）布尔{
rv:=真
对于i，u:=范围计数器.racers{
if counter.racers[0]！=counter.racers[i]{
rv=假
打破
}
}
返回rv
}
func小型计数器（racerNumber int）布尔{
var rv布尔
对于v:=距离计数器。赛车手{
如果计数器。车手[车手编号]=目标{
winner您的程序存在多个问题：


它是快速的。当其他赛车手写入计数器时，您正在读取计数器，而没有任何锁定。可以使用
sync.atomic
函数读取/写入这些值，也可以使用锁定
if counter.racers[0]！=counter.racers[i]{
程序计数器中没有任何位置。racers[0]被写入，因此它始终为零。这意味着，
equalCounter
在其中一个goroutine完成后将始终返回false
smallerCounter
始终返回最后一个赛车手的比较结果。它是一个for循环，重置相同的变量，因此最后一个变量仍然存在
第一个获胜者关闭频道。如果在程序终止之前有其他goroutine写入该频道，将导致恐慌
wg.Wait
在通道读取之前，因此所有goroutine都在等待写入时被锁定
死锁是因为：


结果通道未缓冲，因此多次写入将被阻止，因此
wg.Done（）
永远不会运行
在所有5个
wg.Done（）
运行之前，没有任何内容从结果通道读取（鸡/蛋问题）

快速修复，使结果通道缓冲和所有总写入的大小：

winner = make(chan int, racers)


频道也将在频道队列中获得所有亚军结果

如果你只关心胜利者，有更有效的方法来迎合这种情况，例如创建一个
裁判员
例行程序来观察结果频道的首次写入（胜利者），然后取消比赛（每个参赛者都会观察上下文取消，一旦宣布一个胜利者，他们就会放弃任务）
他们在完成之前都会向
winner
写入，但是
main
会等待他们在读取
winner
之前完成，并且
winner
是无缓冲的。