Go 语言提供两类锁: 互斥锁(Mutex)和读写锁(RWMutex)。
其中读写锁(RWMutex)是基于互斥锁(Mutex)实现的，我们看读写锁的定义(sync/rwmutex.go)：

type RWMutex struct {
    w           Mutex  // held if there are pending writers
    writerSem   uint32 // semaphore for writers to wait for completing readers
    readerSem   uint32 // semaphore for readers to wait for completing writers
    readerCount int32  // number of pending readers
    readerWait  int32  // number of departing readers
}

读写锁里面内置了一个互斥锁。

---

互斥锁的使用

func (m *Mutex) Lock()
func (m *Mutex) Unlock()

互斥锁提供两个API，Lock和Unlock，按字面意思一个是加锁，另一个是释放锁。

• 当一个互斥锁被Lock了以后，任何goroutines(不管是不是当前Lock了这个锁的goroutine)试图再Lock这个锁时都会被挂起，直到锁被释放Unlock。
• 互斥锁不是可重入的，也就是说锁被一个goroutine Lock了之后，当前goroutine也不能再对当前锁进行Lock操作，否则也会被挂起。(如果当前环境只有一个活动goroutine，go会报死锁错误 fatal error: all goroutines are asleep - deadlock!)
• 因为go语言的Mutex并不和任何goroutine相关联，这需要对比Linux pthread里面的线程锁的差异
• 正因为Mutex并不与特定的goroutine相关联，所以一个互斥锁被一个goroutine锁住了，它可以在另外一个goroutine里面被解锁Unlock。

总之

1. 一个已经锁住的互斥锁不能再次被锁住，不管是同一个还是另一个goroutine
2. 一个已经释放的互斥锁也不能再次被释放，不管是同一个还是另一个goroutine

读写锁

    func (rw *RWMutex) RLock()
    func (rw *RWMutex) RUnlock()
    func (rw *RWMutex) Lock()
    func (rw *RWMutex) Unlock()

和互斥锁相比较，读写锁增加了两个RLock()/RUnLock()，我们把它定义为读锁，另一个相对就叫写锁。
读写锁和pthread的的读写锁类似，可以多人同时锁住读锁，但是写锁只能有一个人锁住。

• 当读写锁被一个goroutine加了读锁，此读写锁还能被任何goroutine加读锁，但不能加写锁(会等待直到所有读锁释放)
• 当读写锁被一个goroutine加了写锁，任何goroutine将不能再对此读写锁加锁，不管是加读锁还是加写锁
• 当读写锁被一个goroutine加了读锁，在同一个gorounte内，它不能再被加写锁，但可以加读锁；同样
• 当读写锁被一个goroutine加了写锁，在同一个gorounte内，它不能再被加读锁，加写锁也不能。

因为RWMutex和Mutex一样并不与特定的goroutine相关联，所有的锁操作并不区分是哪一个goroutine进来的请求，是同一个goroutine还是不同的goroutine一同对待。

总结一点

1. goroutine并不是和unix的thread一个概念，他们不具有一一对应关系。
2. go语言的锁也并不与任何特定的goroutine相关联，锁并没有记录当前是哪个goroutine锁住了自己。

可能是因为既然goroutine并不直接相关联与一个thread，同一个thread可能关联到多个goroutine(请阅读goroutine模型的文章)，所以锁无法确切地区分是哪一个thread，所以也没有办法做到关联。