【Go学习】GO语言并发编程之读写锁

【Go学习】GO语言并发编程之读写锁

读写锁是针对于读写操作的互斥锁。

基本遵循两大原则：

1、可以随便读。多个goroutin同时读。

2、写的时候，啥都不能干。不能读，也不能写。
解释：

在32位的操作系统中，针对int64类型值的读操作和写操作不可能只由一个CPU指令完成。如果一个写的操作刚执行完了第一个指令，时间片换给另一个读的协程，这就会读到一个错误的数据。

RWMutex提供四个方法：

func (*RWMutex) Lock //写锁定

func (*RWMutex) Unlock //写解锁

func (*RWMutex) RLock //读锁定

func (*RWMutex) RUnlock //读解锁

下面代码实例可以验证下是不是可以随便读：

package main

import (
    "sync"
    "time"
)

var m *sync.RWMutex

func main() {

    m = new(sync.RWMutex)
    //可以多个同时读
    go read(1)
    go read(2)
    go read(3)
    go read(4)
    time.Sleep(3 * time.Second)

}

func read(i int) {

    println(i, "read start")
    m.RLock()
    println(i, "reading")
    time.Sleep(1 * time.Second)
    m.RUnlock()
    println(i, "read end")

}

运行结果：

1 read start
1 reading
4 read start
4 reading
2 read start
2 reading
3 read start
3 reading
1 read end
3 read end
4 read end

可以看到1读还没结束（倒数第三行）的时候，2，3，4已经在读了。

下面代码实例可以验证是不是写的时候，其他操作都不能进行，并且读的时候，也不能写操作：

package main

import (
    "sync"
    "time"
)

var m *sync.RWMutex

func main() {

    m = new(sync.RWMutex)
    //写的时候啥都不能干
    go write(1)
    go read(2)
    go write(3)
    time.Sleep(5 * time.Second)

}

func read(i int) {
    println(i, "read start")
    m.RLock()
    println(i, "reading")
    time.Sleep(1 * time.Second)
    m.RUnlock()
    println(i, "read end")

}

func write(i int) {

    println(i, "write start")
    m.Lock()
    println(i, "writing")
    time.Sleep(1 * time.Second)
    m.Unlock()
    println(i, "write end")

}

运行结果：

1 write start
1 writing
3 write start
2 read start
1 write end
2 reading
2 read end
3 writing
3 write end

可以看到：

1、1 write end结束之后，2才能reading
2、2 read end结束之后，3 才能writing