mirror of
https://github.com/golang/net.git
synced 2026-04-01 02:47:08 +09:00
b1ec120c3e
Rewrite the synchronization used in Transport tests. This replaces the explicit synchronization, which requires annotating every point where a goroutine in the code under test may block, with implicit syncronization based on parsing goroutine stacks to identify when all goroutines of interest are blocked. Change-Id: I02646e2752c359ed1b08126370a48f3d3c1fde77 Reviewed-on: https://go-review.googlesource.com/c/net/+/584895 Reviewed-by: Jonathan Amsterdam <jba@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
86 lines
1.9 KiB
Go
86 lines
1.9 KiB
Go
// Copyright 2024 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
package http2
|
|
|
|
import "context"
|
|
|
|
// An gate is a monitor (mutex + condition variable) with one bit of state.
|
|
//
|
|
// The condition may be either set or unset.
|
|
// Lock operations may be unconditional, or wait for the condition to be set.
|
|
// Unlock operations record the new state of the condition.
|
|
type gate struct {
|
|
// When unlocked, exactly one of set or unset contains a value.
|
|
// When locked, neither chan contains a value.
|
|
set chan struct{}
|
|
unset chan struct{}
|
|
}
|
|
|
|
// newGate returns a new, unlocked gate with the condition unset.
|
|
func newGate() gate {
|
|
g := newLockedGate()
|
|
g.unlock(false)
|
|
return g
|
|
}
|
|
|
|
// newLocked gate returns a new, locked gate.
|
|
func newLockedGate() gate {
|
|
return gate{
|
|
set: make(chan struct{}, 1),
|
|
unset: make(chan struct{}, 1),
|
|
}
|
|
}
|
|
|
|
// lock acquires the gate unconditionally.
|
|
// It reports whether the condition is set.
|
|
func (g *gate) lock() (set bool) {
|
|
select {
|
|
case <-g.set:
|
|
return true
|
|
case <-g.unset:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// waitAndLock waits until the condition is set before acquiring the gate.
|
|
// If the context expires, waitAndLock returns an error and does not acquire the gate.
|
|
func (g *gate) waitAndLock(ctx context.Context) error {
|
|
select {
|
|
case <-g.set:
|
|
return nil
|
|
default:
|
|
}
|
|
select {
|
|
case <-g.set:
|
|
return nil
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
}
|
|
}
|
|
|
|
// lockIfSet acquires the gate if and only if the condition is set.
|
|
func (g *gate) lockIfSet() (acquired bool) {
|
|
select {
|
|
case <-g.set:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// unlock sets the condition and releases the gate.
|
|
func (g *gate) unlock(set bool) {
|
|
if set {
|
|
g.set <- struct{}{}
|
|
} else {
|
|
g.unset <- struct{}{}
|
|
}
|
|
}
|
|
|
|
// unlock sets the condition to the result of f and releases the gate.
|
|
// Useful in defers.
|
|
func (g *gate) unlockFunc(f func() bool) {
|
|
g.unlock(f())
|
|
}
|