1var mu sync.Mutex
2mu.Lock()
3// 临界区代码
4mu.Unlock()

1var rwmu sync.RWMutex
2rwmu.RLock()   // 读锁
3rwmu.RUnlock() // 读操作
4
5rwmu.Lock()   // 写锁
6rwmu.Unlock() // 写操作

 1const (
 2	mutexLocked = 1 << iota // mutex is locked
 3	mutexWoken
 4	mutexStarving
 5	mutexWaiterShift = iota
 6
 7	// Mutex fairness.
 8	//
 9	// Mutex can be in 2 modes of operations: normal and starvation.
10	// In normal mode waiters are queued in FIFO order, but a woken up waiter
11	// does not own the mutex and competes with new arriving goroutines over
12	// the ownership. New arriving goroutines have an advantage -- they are
13	// already running on CPU and there can be lots of them, so a woken up
14	// waiter has good chances of losing. In such case it is queued at front
15	// of the wait queue. If a waiter fails to acquire the mutex for more than 1ms,
16	// it switches mutex to the starvation mode.
17	//
18	// In starvation mode ownership of the mutex is directly handed off from
19	// the unlocking goroutine to the waiter at the front of the queue.
20	// New arriving goroutines don't try to acquire the mutex even if it appears
21	// to be unlocked, and don't try to spin. Instead they queue themselves at
22	// the tail of the wait queue.
23	//
24	// If a waiter receives ownership of the mutex and sees that either
25	// (1) it is the last waiter in the queue, or (2) it waited for less than 1 ms,
26	// it switches mutex back to normal operation mode.
27	//
28	// Normal mode has considerably better performance as a goroutine can acquire
29	// a mutex several times in a row even if there are blocked waiters.
30	// Starvation mode is important to prevent pathological cases of tail latency.
31	starvationThresholdNs = 1e6
32)

 1// TryLock tries to lock m and reports whether it succeeded.
 2//
 3// Note that while correct uses of TryLock do exist, they are rare,
 4// and use of TryLock is often a sign of a deeper problem
 5// in a particular use of mutexes.
 6func (m *Mutex) TryLock() bool {
 7	old := m.state
 8	if old&(mutexLocked|mutexStarving) != 0 {
 9		return false
10	}
11
12	// There may be a goroutine waiting for the mutex, but we are
13	// running now and can try to grab the mutex before that
14	// goroutine wakes up.
15	if !atomic.CompareAndSwapInt32(&m.state, old, old|mutexLocked) {
16		return false
17	}
18
19	if race.Enabled {
20		race.Acquire(unsafe.Pointer(m))
21	}
22	return true
23}