一、前言

go语言类似Java JUC包也提供了一些列用于多线程之间进行同步的措施，比如低级的同步措施有 锁、CAS、原子变量操作类。相比Java来说go提供了独特的基于通道的同步措施。本节我们先来看看go中读写锁

二、读写锁

go中读写锁，在没有线程获取写锁情况下多个线程可以同时获取读锁，读锁是可重入锁，写锁则是互斥锁（不可重入）。

package main

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

var (
    counter int            //计数器
    wg      sync.WaitGroup //信号量
    lock    sync.RWMutex   //读写锁
)

func main() {

    //1.两个信号
    wg.Add(1)

    //2.获取读锁
    fmt.Println("main thread wait rlock")
    lock.RLock()
    fmt.Println("main thread got rlock")
    //3.开启子线程
    go incCounter()
    fmt.Println(counter)
    time.Sleep(time.Second * 5)
    //4.释放读锁
    lock.RUnlock()
    fmt.Println("main thread release rlock")

    //5.等待子线程结束
    wg.Wait()
    fmt.Println(counter)

}

func incCounter() {
    defer wg.Done()

    //2.1.获取锁
    fmt.Println("sub thread wait rlock")
    lock.Lock()
    fmt.Println("sub thread got rlock")

    //2.2.计数加1
    counter++

    //2.3.释放独占锁
    lock.Unlock()
    fmt.Println("sub thread relese rlock")

}

• 如上代码go中使用sync.RWMutex可以获取一个开箱即用的读写锁
• 代码（2）主线程使用lock.RLock()获取读锁，然后开启了子线程（代码3），然后在主线程持有读锁的情况下休眠了5s后释放了锁。
• 子线程在代码2.1尝试使用 lock.Lock()获取写锁，由于主线程还没释放读锁，所以子线程阻塞到了这里，直到主线程休眠后执行代码4释放了读锁。
• 执行代码会输出：

main thread wait rlock
main thread got rlock
0
sub thread wait rlock
main thread release rlock
sub thread got rlock
sub thread relese rlock
1

这个例子说明了，当有线程获取了读锁并没释放时候，获取写锁的线程要等待。

另外使用下面方法可以验证读锁是可重入锁：

    lock.RLock()
    lock.RLock()
    fmt.Println(counter)
    lock.RUnlock()
    lock.RUnlock()

使用下面代码可以验证同一个线程的读锁，不能晋升为写锁：

    lock.RLock()
    lock.Lock()
    fmt.Println(counter)
    lock.Unlock()
    lock.RUnlock()

上面代码执行会报错：

三、总结

go中读写锁中的读锁是可重入共享锁，写锁是互斥锁，读锁不能晋升为写锁。