// Copyright 2009 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 sync provides basic synchronization primitives such as mutual

// exclusion locks. Other than the [Once] and [WaitGroup] types, most are intended

// for use by low-level library routines. Higher-level synchronization is

// better done via channels and communication.

//

// Values containing the types defined in this package should not be copied.

package sync

import (

isync "internal/sync"

)

// A Mutex is a mutual exclusion lock.

// The zero value for a Mutex is an unlocked mutex.

//

// A Mutex must not be copied after first use.

//

// In the terminology of [the Go memory model],

// the n'th call to [Mutex.Unlock] “synchronizes before” the m'th call to [Mutex.Lock]

// for any n < m.

// A successful call to [Mutex.TryLock] is equivalent to a call to Lock.

// A failed call to TryLock does not establish any “synchronizes before”

// relation at all.

//

// [the Go memory model]: https://go.dev/ref/mem

type Mutex struct {

}

// A Locker represents an object that can be locked and unlocked.

type Locker interface {

Lock()

Unlock()

}

// Lock locks m.

// If the lock is already in use, the calling goroutine

// blocks until the mutex is available.

func (m *Mutex) Lock() {

m.mu.Lock()

}

// TryLock tries to lock m and reports whether it succeeded.

//

// Note that while correct uses of TryLock do exist, they are rare,

// and use of TryLock is often a sign of a deeper problem

// in a particular use of mutexes.

func (m *Mutex) TryLock() bool {

return m.mu.TryLock()

}

// Unlock unlocks m.

// It is a run-time error if m is not locked on entry to Unlock.

//

// A locked [Mutex] is not associated with a particular goroutine.

// It is allowed for one goroutine to lock a Mutex and then

// arrange for another goroutine to unlock it.

func (m *Mutex) Unlock() {

m.mu.Unlock()

}