锁

前面我们为了解决 go 程同步的问题我们使用了 channel，但是 GO 也提供了传统的同步工具。
它们都在 GO 的标准库代码包 sync 和 sync/atomic 中。
下面我们看一下锁的应用。
什么是锁呢？就是某个 go 程（线程）在访问某个资源时先锁住，防止其它 go 程的访问，等访问完毕解锁后其他 go 程再来加锁进行访问。这和我们生活中加锁使用公共资源相似，例如：公共卫生间。

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，

示例代码：

package main

import "fmt"

func main() {
ch := make(chan int)
ch <- 1         // I'm blocked because there is no channel read yet.
fmt.Println("send")
go func() {
    <-ch        // I will never be called for the main routine is blocked!
    fmt.Println("received")
}()
fmt.Println("over")
}

互斥锁

每个资源都对应于一个可称为 "互斥锁" 的标记，这个标记用来保证在任意时刻，只能有一个 go 程（线程）访问该资源。其它的 go 程只能等待。

互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库 sync 中的 Mutex 结构体类型表示。sync.Mutex 类型只有两个公开的指针方法，Lock 和 Unlock。Lock 锁定当前的共享资源，Unlock 进行解锁。

在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助 defer。锁定后，立即使用 defer 语句保证互斥锁及时解锁。如下所示：

var mutex sync.Mutex        // 定义互斥锁变量 mutex

func write(){
   mutex.Lock( )
   defer mutex.Unlock( )
}

我们可以使用互斥锁来解决前面提到的多任务编程的问题，如下所示：

package main

import (
   "fmt"
   "time"
   "sync"
)

var mutex sync.Mutex

func printer(str string)  {
   mutex.Lock()                 // 添加互斥锁
   defer mutex.Unlock()             // 使用结束时解锁

   for _, data := range str {       // 迭代器
      fmt.Printf("%c", data)
      time.Sleep(time.Second)       // 放大go程竞争效果
   }
   fmt.Println()            
}

func person1(s1 string)  {
   printer(s1)
}

func person2()  {
   printer("world")         // 调函数时传参
}

func main()  {
   go person1("hello")          // main 中传参
   go person2()
   for {
      ;
   }
}

程序执行结果与多任务资源竞争时一致。最终由于添加了互斥锁，可以按序先输出 hello 再输出 world。但这里需要我们自行创建互斥锁，并在适当的位置对锁进行释放。

读写锁

互斥锁的本质是当一个 goroutine 访问的时候，其他 goroutine 都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。

其实，当我们对一个不会变化的数据只做 “读” 操作的话，是不存在资源竞争的问题的。因为数据是不变的，不管怎么读取，多少 goroutine 同时读取，都是可以的。

所以问题不是出在 “读” 上，主要是修改，也就是 “写”。修改的数据要同步，这样其他 goroutine 才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。

因此，衍生出另外一种锁，叫做读写锁。

读写锁可以让多个读操作并发，同时读取，但是对于写操作是完全互斥的。也就是说，当一个 goroutine 进行写操作的时候，其他 goroutine 既不能进行读操作，也不能进行写操作。

GO 中的读写锁由结构体类型 sync.RWMutex 表示。此类型的方法集合中包含两对方法：

一组是对写操作的锁定和解锁，简称 “写锁定” 和 “写解锁”：

func (*RWMutex)Lock()
func (*RWMutex)Unlock()

另一组表示对读操作的锁定和解锁，简称为 “读锁定” 与 “读解锁”：

func (*RWMutex)RLock()
func (*RWMutex)RUnlock()

读写锁基本示例：

package main

import (
   "sync"
   "fmt"
   "math/rand"
)

var count int                   // 全局变量count
var rwlock sync.RWMutex         // 全局读写锁 rwlock

func read(n int)  {
   rwlock.RLock()
   fmt.Printf("读 goroutine %d 正在读取数据...\n", n)
   num := count
   fmt.Printf("读 goroutine %d 读取数据结束，读到 %d\n", n, num)
   defer rwlock.RUnlock()
}
func write(n int)  {
   rwlock.Lock()
   fmt.Printf("写 goroutine %d 正在写数据...\n", n)
   num := rand.Intn(1000)
   count = num
   fmt.Printf("写 goroutine %d 写数据结束，写入新值 %d\n", n, num)
   defer rwlock.Unlock()
}

func main()  {
   for i:=0; i<5; i++ {
      go read(i+1)
   }
   for i:=0; i<5; i++ {
      go write(i+1)
   }
   for {
      ;
   }
}

程序的执行结果：

我们在 read 里使用读锁，也就是 RLock 和 RUnlock，写锁的方法名和我们平时使用的一样，是 Lock 和 Unlock。这样，我们就使用了读写锁，可以并发地读，但是同时只能有一个写，并且写的时候不能进行读操作。

我们从结果可以看出，读取操作可以并行，例如 2,3,1 正在读取，但是同时只能有一个写，例如 1 正在写，只能等待 1 写完，这个过程中不允许进行其它的操作。

处于读锁定状态，那么针对它的写锁定操作将永远不会成功，且相应的 Goroutine 也会被一直阻塞。因为它们是互斥的。

总结：读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间不存在互斥关系。

从互斥锁和读写锁的源码可以看出，它们是同源的。读写锁的内部用互斥锁来实现写锁定操作之间的互斥。可以把读写锁看作是互斥锁的一种扩展。