Golang 如何保证数据在一个 goroutine 中完成，同时被另一个 goroutine 访问

Question

大家好，我正在尝试使用 websockets 制作一个聚会系统，人们可以在其中进入队列，然后与 5 个与他们相似的人匹配。现在我在这部分遇到了问题:

type PartyHub struct {
    Partys             map[string]*Party
    PartialPartys      []*PartialParty
    Queue              []*Member
    AddParty           chan *Party
    RemoveParty        chan *Party
    AddPartialParty    chan *PartialParty
    RemovePartialParty chan *PartialParty
    EnterQueue         chan *Member
    LeaveQueue         chan *Member
    Mu                 sync.Mutex
}
// Run will begin monitoring the channels
// to register and unregister partys as they are
// created or destroyed
func (p *PartyHub) Run() {
    for {
        select {
        case member := <-p.EnterQueue:
            go p.SortMemberIntoParty(member)
            go p.SortMemberIntoParty(member)
            go p.SortMemberIntoParty(member)
            go p.SortMemberIntoParty(member)
            go p.SortMemberIntoParty(member)

            log.Println(p.PartialPartys)
        case party := <-p.AddPartialParty:
            p.Mu.Lock()
            defer p.Mu.Unlock()
            p.PartialPartys = append(p.PartialPartys, party)
        }
    }
}

// SortMemberIntoParty will take a new user entering the queue and find an appropriate Party
// for the member to join, taking into account RankTollerance, Rank
func (p *PartyHub) SortMemberIntoParty(member *Member) {
    p.Mu.Lock()
    defer p.Mu.Unlock()
    if len(p.PartialPartys) == 0 {
        log.Println("Here")
        newParty := &PartialParty{Accepting: true, Members: []*Member{member}}
        p.AddPartialParty <- newParty
        return
    }

    foundPartyForMember := false
    for _, party := range p.PartialPartys {
        goodFitForParty := true
        for _, partyMember := range party.Members {
            log.Println(member.Type == partyMember.Type, member.Rank >= partyMember.Rank-partyMember.RankTol, member.Rank <= partyMember.Rank+partyMember.RankTol)
            if member.Type == partyMember.Type && member.Rank >= partyMember.Rank-partyMember.RankTol && member.Rank <= partyMember.Rank+partyMember.RankTol {

                goodFitForParty = true
                continue
            } else {
                goodFitForParty = false
                break
            }
        }

        if !goodFitForParty {
            continue
        } else {
            foundPartyForMember = true
            party.Mu.Lock()
            defer party.Mu.Unlock()
            party.Members = append(party.Members, member)
            if len(party.Members) == 5 {
                party.Accepting = false
                go party.SendReadyCheck()
            }
            break
        }
    }


    if !foundPartyForMember {
        newParty := &PartialParty{Accepting: true, Members: []*Member{member}}
        p.AddPartialParty <- newParty
    }

    log.Println("Sorting Members")
}

唯一的问题是，5 个 goroutines 似乎比数据知道发生了什么更快完成。

例如:p.PartialPartys 表示它没有派对。

我需要的是让 p.PartialPartys 始终为每个访问 PartyHub 结构字段的 goroutine 保持最新sync.Mutex 会为我做这件事，但似乎并非如此，有人能告诉我让我的所有 goroutine 与相同数据保持同步的最佳方法吗？

Answer 1

因此，通过此实现，您的五个 goroutine 都无法并行运行，因为它们都在尝试获取 p.Mu 互斥量。看看您使用 p.AddPartialParty channel 的方式，如果代码会死锁，我不会感到惊讶。

考虑以下事件序列:

1. 其中一个 SortMemberIntoParty goroutine 开始运行并获取互斥量。
2. 它在 p.AddPartialParty 上发送一个值，该值由 Run 接收。 Run 然后尝试获取互斥锁，因此阻塞。
3. 原始 SortMemberIntoParty goroutine 完成并释放互斥体。
4. 不同的 SortMemberIntoParty goroutine 获取互斥量，并尝试将另一个值发送到 p.AddPartialParty。
5. goroutine 阻塞是因为没有人准备好读取值(Run 在返回到 select 语句之前仍在等待互斥量)。<

现在您已经有了一个阻塞的 goroutine，它持有 channel 接收端所需的锁。另请注意，在 (4) 处您不会看到新的 PartialParty，因为 Run 尚未设法添加它。

如果您确实需要互斥量，那么直接让您的 SortMemberIntoParty goroutine 更新 p.PartialPartys 比使用 channel 更容易:您已经知道没有其他人会同时访问该变量。

同样值得记住的是，这个互斥锁本质上意味着所有 SortMemberIntoParty goroutines 都将被序列化。如果您使用 goroutines 是希望在这里实现并行性，那么互斥量会打败它。