堕落不振功业废,勤耕不辍日月新

golang sync包互斥锁和读写锁的使用

Python hailen 18℃

golang sync包里提供了 Locker接口、互斥锁 Mutex、读写锁 RWMutex用于处理并发过程中可能出现同时两个或多个协程(或线程)读或写同一个变量的情况。

一、为什么需要锁

在并发的情况下,多个线程或协程同时去修改一个变量。使用锁能保证在某一时间点内,只有一个协程或线程修改这一变量,具体我们可以看示例。先看不加锁的程序(会出现多个程序同时读该变量):

package main
import (
    "fmt"
    "time"
)
func main() {
    var a = 0
    for i := 0; i < 1000; i++ {
        go func(idx int) {
            a += 1
            fmt.Println(a)
        }(i)
    }
    time.Sleep(time.Second)
}

从理论上来说,上面的函数是每次递增a的值的,所以理论上应该会有1000个不同的值输出,实际结果呢?

[root@361way test]# go run l1.go |sort|uniq |wc -l
998
[root@361way test]# go run l1.go |sort|uniq |wc -l
1000
[root@361way test]# go run l1.go |sort|uniq |wc -l
998
[root@361way test]# go run l1.go |sort|uniq |wc -l
999

这里运行了4次,获取了三个不一样的结果。如果你有精力,可以将运行的结果逐一对比,在出现wc -l的结果小于1000时,绝对出现了重复值。为什么会现这样的情况?

协程依次执行:从寄存器读取 a 的值 -> 然后做加法运算 -> 最后写到寄存器。试想,此时一个协程取出 a 的值 3,正在做加法运算(还未写回寄存器)。同时另一个协程此时去取,取出了同样的 a 的值 3。最终导致的结果是,两个协程产出的结果相同,a 相当于只增加了 1。

所以,锁的概念就是,我正在处理 a(锁定),你们谁都别和我抢,等我处理完了(解锁),你们再处理。这样就实现了,同时处理 a 的协程只有一个,就实现了同步。

注:上面的方法是多协程的,增加runtime.GOMAXPROCS(4) 改为多进程多线程同样会有这样的问题

二、互斥锁 Mutex

上面的示例中出现的问题怎么解决?加一个互斥锁 Mutex就OK了。哪什么是互斥锁 ?其有两个方法可以调用,如下:

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

我们改下循环递增示例中的代码,如下:

package main
import (
    "fmt"
    "time"
)
func main() {
    var a = 0
    var lock sync.Mutex
    for i := 0; i < 1000; i++ {
        go func(idx int) {
            lock.Lock()
            defer lock.Unlock()
            a += 1
            fmt.Printf("goroutine %d, a=%d
", idx, a)
        }(i)
    }
    // 等待 1s 结束主程序
    // 确保所有协程执行完
    time.Sleep(time.Second)
}

修改后执行的结果总是1000个不重服的值。而且使用go语言的lock锁一般不会出现忘了解锁的情况,因类其紧跟锁定的就是defer Unlock 。

需要注意的是一个互斥锁只能同时被一个 goroutine 锁定,其它 goroutine 将阻塞直到互斥锁被解锁(重新争抢对互斥锁的锁定)。看如下代码:

package main
import (
    "fmt"
    "sync"
    "time"
)
func main() {
    ch := make(chan struct{}, 2)
    var l sync.Mutex
    go func() {
        l.Lock()
        defer l.Unlock()
        fmt.Println("goroutine1: 我会锁定大概 2s")
        time.Sleep(time.Second * 2)
        fmt.Println("goroutine1: 我解锁了,你们去抢吧")
        ch <- struct{}{}
    }()
    go func() {
        fmt.Println("groutine2: 等待解锁")
        l.Lock()
        defer l.Unlock()
        fmt.Println("goroutine2: 欧耶,我也解锁了")
        ch <- struct{}{}
    }()
    // 等待 goroutine 执行结束
    for i := 0; i < 2; i++ {
        <-ch
    }
}

上面的代码执行结果如下:

[root@361way test]# go run l2.go
goroutine1: 我会锁定大概 2s
groutine2: 等待解锁
goroutine1: 我解锁了,你们去抢吧
goroutine2: 欧耶,我也解锁了

三、读写锁

读写锁有如下四个方法:

写操作的锁定和解锁
* func (*RWMutex) Lock
* func (*RWMutex) Unlock
读操作的锁定和解锁
* func (*RWMutex) Rlock
* func (*RWMutex) RUnlock

注:区别在后的Lock和Unlock前有没有R 。

我们怎么理解读写锁呢?当有一个 goroutine 获得写锁定,其它无论是读锁定还是写锁定都将阻塞直到写解锁;当有一个 goroutine 获得读锁定,其它读锁定仍然可以继续;当有一个或任意多个读锁定,写锁定将等待所有读锁定解锁之后才能够进行写锁定。所以说这里的读锁定(RLock)目的其实是告诉写锁定:有很多人正在读取数据,你给我站一边去,等它们读(读解锁)完你再来写(写锁定)。我们可以将其总结为如下三条:

同时只能有一个 goroutine 能够获得写锁定。
同时可以有任意多个 gorouinte 获得读锁定。
同时只能存在写锁定或读锁定(读和写互斥)。

看个示例:

package main
import (
    "fmt"
    "math/rand"
    "sync"
)
var count int
var rw sync.RWMutex
func main() {
    ch := make(chan struct{}, 10)
    for i := 0; i < 5; i++ {
        go read(i, ch)
    }
    for i := 0; i < 5; i++ {
        go write(i, ch)
    }
    for i := 0; i < 10; i++ {
        <-ch
    }
}
func read(n int, ch chan struct{}) {
    rw.RLock()
    fmt.Printf("goroutine %d 进入读操作...
", n)
    v := count
    fmt.Printf("goroutine %d 读取结束,值为:%d
", n, v)
    rw.RUnlock()
    ch <- struct{}{}
}
func write(n int, ch chan struct{}) {
    rw.Lock()
    fmt.Printf("goroutine %d 进入写操作...
", n)
    v := rand.Intn(1000)
    count = v
    fmt.Printf("goroutine %d 写入结束,新值为:%d
", n, v)
    rw.Unlock()
    ch <- struct{}{}
}

其执行结果如下:

[root@361way test]# go run l3.go
goroutine 4 进入写操作...
goroutine 4 写入结束,新值为:81
goroutine 2 进入读操作...
goroutine 2 读取结束,值为:81
goroutine 3 进入读操作...
goroutine 3 读取结束,值为:81
goroutine 0 进入读操作...
goroutine 0 读取结束,值为:81
goroutine 1 进入读操作...
goroutine 4 进入读操作...
goroutine 4 读取结束,值为:81
goroutine 1 读取结束,值为:81
goroutine 0 进入写操作...
goroutine 0 写入结束,新值为:887
goroutine 1 进入写操作...
goroutine 1 写入结束,新值为:847
goroutine 3 进入写操作...
goroutine 3 写入结束,新值为:59
goroutine 2 进入写操作...
goroutine 2 写入结束,新值为:81

再来看两个例子:

package main
import (
    "sync"
    "time"
)
var m *sync.RWMutex
func main() {
    m = new(sync.RWMutex)
    // 多个同时读
    go read(1)
    go read(2)
    time.Sleep(2*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 over")
}

这里例子中,多个读操作同时读一个操作。虽然加了锁,但都是读是不受影响的。(读和写是互斥的,读和读不互斥—-我靠,这是同性才是真爱的节奏啊)。

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(2*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 over")
}
func write(i int) {
    println(i,"write start")
    m.Lock()
    println(i,"writing")
    time.Sleep(1*time.Second)
    m.Unlock()
    println(i,"write over")
}

由于读写互斥,上面这个示例中,写开始的时候,读必须要等写进行完才能继续。不然他只能继续等待,这就像只有一个茅坑,别我蹲着,你着急也不能去抢(为什么?有门关着呢!)。

golang sync包互斥锁和读写锁的使用,首发于运维之路

转载请注明:我是IT » golang sync包互斥锁和读写锁的使用

喜欢 (0)or分享 (0)