Clear()
}

var (
	_ mapInterface = &RWMutexMap{}
	_ mapInterface = &DeepCopyMap{}
)

// RWMutexMap is an implementation of mapInterface using a sync.RWMutex.
type RWMutexMap struct {
	mu    sync.RWMutex
	dirty map[any]any
}

func (m *RWMutexMap) Load(key any) (value any, ok bool) {
	m.mu.RLock()
	value, ok = m.dirty[key]
	m.mu.RUnlock()
	return
}

package socktest

import (
	"fmt"
	"sync"
)

// A Switch represents a callpath point switch for socket system
// calls.
type Switch struct {
	once sync.Once

	fmu   sync.RWMutex
	fltab map[FilterType]Filter

	smu   sync.RWMutex
	sotab Sockets
	stats stats
}

func (sw *Switch) init() {
	sw.fltab = make(map[FilterType]Filter)
	sw.sotab = make(Sockets)
	sw.stats = make(stats)
}

		UpgradeManifests:                 &metav1.Duration{Duration: constants.UpgradeManifestsTimeout},
	}
}

var (
	activeTimeouts *Timeouts = nil
	timeoutMutex             = &sync.RWMutex{}
)

func init() {
	SetDefaultTimeouts(&activeTimeouts)
}

// GetActiveTimeouts gets the active timeouts structure.
func GetActiveTimeouts() *Timeouts {
	timeoutMutex.RLock()
	defer timeoutMutex.RUnlock()

limitations under the License.
*/

package waitgroup

import (
	"fmt"
	"sync"
)

// SafeWaitGroup must not be copied after first use.
type SafeWaitGroup struct {
	wg sync.WaitGroup
	mu sync.RWMutex
	// wait indicate whether Wait is called, if true,
	// then any Add with positive delta will return error.
	wait bool
}

// Add adds delta, which may be negative, similar to sync.WaitGroup.

)

var (
	clusterLabel = monitoring.CreateLabel("cluster")

	errorMetric = monitoring.NewSum(
		"controller_sync_errors_total",
		"Total number of errorMetric syncing controllers.",
	)

	mu       sync.RWMutex
	handlers = map[cluster.ID]cache.WatchErrorHandler{}
)

// ErrorHandlerForCluster fetches or creates an ErrorHandler that emits a metric

	"github.com/minio/minio/internal/config/ilm"
)

var globalILMConfig = ilmConfig{
	cfg: ilm.Config{
		ExpirationWorkers: 100,
		TransitionWorkers: 100,
	},
}

type ilmConfig struct {
	mu  sync.RWMutex
	cfg ilm.Config
}

func (c *ilmConfig) getExpirationWorkers() int {
	c.mu.RLock()
	defer c.mu.RUnlock()

	return c.cfg.ExpirationWorkers
}

func (c *ilmConfig) getTransitionWorkers() int {

package cmd

import (
	"context"
	"sync"

	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/pubsub"
)

const bootstrapTraceLimit = 4 << 10

type bootstrapTracer struct {
	mu   sync.RWMutex
	info []madmin.TraceInfo
}

var globalBootstrapTracer = &bootstrapTracer{}

func (bs *bootstrapTracer) Record(info madmin.TraceInfo) {
	bs.mu.Lock()
	defer bs.mu.Unlock()

	SetMaxSeats(priorityLevelName string, maxSeats uint64)

	// ForgetPriorityLevel removes max seats tracking for a priority level.
	ForgetPriorityLevel(priorityLevelName string)
}

type maxSeatsTracker struct {
	sync.RWMutex

	maxSeats map[string]uint64
}

func NewMaxSeatsTracker() MaxSeatsTracker {
	return &maxSeatsTracker{
		maxSeats: make(map[string]uint64),
	}
}

import (
	"context"
	"sync"

	"go.opentelemetry.io/otel/attribute"
	api "go.opentelemetry.io/otel/metric"

	"istio.io/istio/pkg/log"
	"istio.io/istio/pkg/slices"
)

type derivedGauge struct {
	mu    sync.RWMutex
	attrs map[attribute.Set]func() float64

	name string
}

var _ DerivedMetric = &derivedGauge{}

func newDerivedGauge(name, description string) DerivedMetric {
	dm := &derivedGauge{
		name:  name,

	"fmt"
	"sync"

	"istio.io/istio/pilot/cmd/pilot-agent/status/ready"
	"istio.io/istio/pkg/file"
	"istio.io/istio/pkg/istio-agent/grpcxds"
)

var _ ready.Prober = &probe{}

type probe struct {
	sync.RWMutex
	bootstrapPath string
	bootstrap     *grpcxds.Bootstrap
}

// NewProbe returns a probe that checks if a valid bootstrap file can be loaded once.