《MMO 服务器开发》12.2 满员判断与匹配锁定

// snippet: 反面示例，不要照抄

func (p *Party) Invite(actor, target PlayerID) error {
	if p.Count() >= MaxMembers { // ← 这里解锁了
		return ErrPartyFull
	}
	return p.AddMember(actor, target) // ← 这里才加锁写入
}

时刻   goroutine A（邀请 甲）        goroutine B（邀请 乙）
t1     Count() 返回 3，未满
t2                                   Count() 返回 3，未满
t3     members[甲] = ...（此时 4 人）
t4                                   members[乙] = ...  ← 5 人，超编

// file: internal/party/lock.go
// tier: L1
// verify: go test ./internal/party/ -run TestTryJoin -race

package party

// MatchID 是匹配服务给这次匹配分配的单号。锁定后队伍记住它，用于对账
// 「这支队伍到底是在哪一次匹配里被锁的」。
type MatchID uint64

// MatchTicket 是锁定匹配那一刻冻结下来的成员名单。匹配服务只认这张票据，
// 不再回头读队伍对象——队伍在匹配期间怎么抖动都影响不了已经发出的名单。
type MatchTicket struct {
	MatchID MatchID
	Members []PlayerID
}

// Full 判断队伍是否已满员。注意它和 Count 一样只是读快照：真正安全的满员
// 判断发生在 TryJoin 的临界区里，绝不能是「先 Full() 再 AddMember()」。
func (p *Party) Full() bool {
	p.mu.Lock()
	defer p.mu.Unlock()
	return len(p.members) >= MaxMembers
}

// TryJoin 是唯一的入队写路径，把「查满员」和「写成员」压进同一个临界区。
// 两个并发邀请里，只有一个能观察到空位并占到它，另一个必然看到 ErrPartyFull。
// 这是 12.2 的核心修复点：把读-改-写做成原子。
func (p *Party) TryJoin(actor, target PlayerID) (bool, error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.state != StateForming {
		return false, ErrPartyLocked
	}
	if actor != p.leader {
		return false, ErrNotLeader
	}
	if _, ok := p.members[target]; ok {
		return false, ErrAlreadyMember
	}
	if len(p.members) >= MaxMembers {
		return false, ErrPartyFull
	}
	p.members[target] = &Member{PlayerID: target, Role: RoleMember, Online: true}
	p.order = append(p.order, target)
	return true, nil
}

// LockForMatch 把「满员校验」和「状态置为锁定」也做成原子操作。这里有一个
// 真实事故：若先 Full() 判断、再另行 Lock()，两次调用之间可能刚好有人入队，
// 结果一个超编队伍被送进匹配。LockForMatch 把这两步合并，并返回冻结名单。
func (p *Party) LockForMatch(actor PlayerID, mid MatchID) (*MatchTicket, error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.state != StateForming {
		return nil, ErrPartyLocked
	}
	if actor != p.leader {
		return nil, ErrNotLeader
	}
	if len(p.members) < MaxMembers {
		return nil, ErrPartyFull // 未满员不允许锁定匹配
	}
	members := make([]PlayerID, 0, len(p.order))
	for _, id := range p.order {
		members = append(members, id)
	}
	if err := p.setStateLocked(StateLocked); err != nil {
		return nil, err
	}
	return &MatchTicket{MatchID: mid, Members: members}, nil
}

// Unlock 把队伍从锁定态放回组建态。匹配失败、玩家取消、副本结算都走它。
// 队长离线由 12.3 的迁移先补一个新队长，所以这里仍要求 actor 是队长。
func (p *Party) Unlock(actor PlayerID) error {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.state != StateLocked {
		return ErrPartyLocked
	}
	if actor != p.leader {
		return ErrNotLeader
	}
	return p.setStateLocked(StateForming)
}

// EnterDungeon 是锁定 -> 副本的单向推进，只在匹配成功后被调用。
func (p *Party) EnterDungeon(actor PlayerID) error {
	p.mu.Lock()
	defer p.mu.Unlock()
	if actor != p.leader {
		return ErrNotLeader
	}
	return p.setStateLocked(StateInDungeon)
}

时刻   队长线程（提交匹配）           队友线程（拉人）
t1     Full() == true，满员
t2                                    TryJoin(丙) → 成功，队伍变 5 人
t3     Lock() 成功，状态 = Locked
t4     用 5 人名单开房 → 四人副本塞进五人

// snippet: internal/party/party_test.go（节选）

// TestTryJoinRace 是 12.2 的核心证据：把满员判断和写入拆开就会超编，
// 合进一个临界区后，无论并发多凶，成员数都不会越过 MaxMembers。
func TestTryJoinRace(t *testing.T) {
	leader := PlayerID(1)
	p := NewParty(PartyID(9), leader)

	const attempts = 64
	var wg sync.WaitGroup
	var mu sync.Mutex
	joined := 0
	wg.Add(attempts)
	for i := 0; i < attempts; i++ {
		go func(i int) {
			defer wg.Done()
			ok, err := p.TryJoin(leader, PlayerID(1000+i))
			if err != nil && !errors.Is(err, ErrPartyFull) {
				t.Errorf("unexpected err: %v", err)
			}
			if ok {
				mu.Lock()
				joined++
				mu.Unlock()
			}
		}(i)
	}
	wg.Wait()

	if joined != MaxMembers-1 {
		t.Fatalf("joined: want %d, got %d", MaxMembers-1, joined)
	}
	if got := p.Count(); got != MaxMembers {
		t.Fatalf("count: want %d, got %d", MaxMembers, got)
	}
}