Go语言之Go语言锁机制

sunnyJam 2020-03-27

Go 语言锁机制

Go 语言互斥锁

Go语言的sync包中实现了两种锁 Mutex (互斥锁)和 RWMutex (读写锁),其中 RWMutex 是基于 Mutex 实现的,只读锁的实现使用类似引用计数器的功能。

互斥锁

Mutex 是互斥锁,有 Lock()加锁、Unlock()解锁两个方法,使用Lock()加锁后,便不能再次对其进行加锁,直到利用 Unlock()解锁对其解锁后才能再次加锁。适用于读写不确定场景,即读写次数没有明显的区别,并且只允许只有一个读或者写的场景,所以该锁也叫做全局锁。

func (m *Mutex) Lock()

Lock方法锁住m,如果m已经加锁,则阻塞直到m解锁。

func (m *Mutex) Unlock()

Unlock方法解锁m,如果m未加锁会导致运行时错误。锁和线程无关,可以由不同的线程加锁和解锁。

互斥锁应用

只要有两个goroutine并发访问同一变量,且至少其中的一个是写操作的时候就会发生数据竞争。数据竞争会在两个以上的goroutine并发访问相同的变量且至少其中一个为写操作时发生。

允许多个goroutine访问变量,但是同一时间只允许一个goroutine访问。我们可以用sync包中的Mutex来实现,保证共享变量不会被并发访问。

实例如下:

package main

import (
    "fmt"
    "sync"
)

var (
    m     = make(map[int]int)
    Mlock = new(sync.Mutex)
)

func main() {
    for i := 0; i < 1000; i++ {
        go func(i int) {
            // Mlock.Lock()
            m[i] = i * i
            // Mlock.Unlock()
        }(i)
    }

    // Mlock.Lock()
    for k, v := range m {
        fmt.Printf("%d * %d = %d\n", k, k, v)
    }
    // Mlock.Unlock()
}

运行错误:

fatal error: concurrent map writes

将上述代码中的注释打开则程序正常运行。

当Unlock()在Lock()之前使用时便会报错,实例如下:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var MLock *sync.Mutex
    MLock = new(sync.Mutex)
    MLock.Unlock()
    fmt.Println("hello Mutex")
    MLock.Lock()
}

运行错误:

panic: sync: unlock of unlocked mutex

当在解锁之前再次进行加锁,便会死锁状态,实例如下:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var MLock *sync.Mutex
    MLock = new(sync.Mutex)
    MLock.Lock()
    fmt.Println("hello Mutex")
    MLock.Lock()
}

运行错误:

fatal error: all goroutines are asleep - deadlock!

互斥锁只能锁定一次,当在解锁之前再次进行加锁,便会死锁状态,如果在加锁前解锁,便会报错“panic: sync: unlock of unlocked mutex”。

Go 语言读写锁

RWMutex是一个读写锁,该锁可以加多个读锁或者一个写锁,其经常用于读次数远远多于写次数的场景。

func (rw *RWMutex) Lock()

Lock方法将rw锁定为写入状态,禁止其他线程读取或者写入。如果在添加写锁之前已经有其他的读锁和写锁,则lock就会阻塞直到该锁可用,为确保该锁最终可用,已阻塞的 Lock 调用会从获得的锁中排除新的读取器,即写锁权限高于读锁,有写锁时优先进行写锁定。

func (rw *RWMutex) Unlock()

Unlock方法解除rw的写入锁状态,如果m未加写入锁会导致运行时错误。

func (rw *RWMutex) RLock()

RLock方法将rw锁定为读取状态,禁止其他线程写入,但不禁止读取。

func (rw *RWMutex) RUnlock()

Runlock方法解除rw的读取锁状态,如果m未加读取锁会导致运行时错误。

读写锁的写锁只能锁定一次,解锁前不能多次锁定,读锁可以多次,但读解锁次数最多只能比读锁次数多一次,一般情况下我们不建议读解锁次数多余读锁

读写锁应用

读多写少的情况,用读写锁, 协程同时在操作读。

package main

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

var rwLock sync.RWMutex

func main() {
    m := make(map[int]int, 5)
    m[1] = 10
    m[2] = 10
    m[3] = 10
    m[4] = 10
    m[5] = 10
    for i := 0; i < 2; i++ {
        go func() {
            rwLock.Lock()
            m[5] = rand.Intn(100)
            rwLock.Unlock()
        }()
    }
    for i := 0; i < 10; i++ {
        go func() {
            rwLock.RLock()
            fmt.Println(m)
            rwLock.RUnlock()
        }()
    }
    time.Sleep(time.Second * 2)
}

当RUnlock()在RLock()之前使用时便会报错,实例如下:

package main

import (
    "fmt"
    "sync"
)

func main() {
    RWLock := new(sync.RWMutex)
    RWLock.RUnlock()
    fmt.Println("hello RWMutex")
    RWLock.RLock()
}

运行错误:

fatal error: sync: RUnlock of unlocked RWMutex

Go 语言锁性能比较

性能比较

一、测试互斥锁性能,20秒程序执行次数。

package main

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

var MLock sync.Mutex

func main() {
    m := make(map[int]int, 5)
    var count int32
    m[1] = 10
    m[2] = 10
    m[3] = 10
    m[4] = 10
    m[5] = 10
    for i := 0; i < 2; i++ {
        go func() {
            MLock.Lock()
            m[5] = rand.Intn(100)
            time.Sleep(10 * time.Microsecond)
            MLock.Unlock()

        }()
    }
    for i := 0; i < 100; i++ {
        go func() {
            for {
                MLock.Lock()
                time.Sleep(time.Millisecond)
                _ = m[5]
                MLock.Unlock()
                atomic.AddInt32(&count, 1)
            }
        }()
    }
    time.Sleep(time.Second * 20)
    fmt.Println(atomic.LoadInt32(&count))
}

二、测试读写锁性能,20秒程序执行次数。

package main

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

var rwLock sync.RWMutex

func main() {
    m := make(map[int]int, 5)
    var count int32
    m[1] = 10
    m[2] = 10
    m[3] = 10
    m[4] = 10
    m[5] = 10
    for i := 0; i < 2; i++ {
        go func() {
            rwLock.Lock()
            m[5] = rand.Intn(100)
            time.Sleep(10 * time.Microsecond)
            rwLock.Unlock()
        }()
    }
    for i := 0; i < 100; i++ {
        go func() {
            for {
                rwLock.RLock()
                time.Sleep(time.Millisecond)
                _ = m[5]
                rwLock.RUnlock()
                atomic.AddInt32(&count, 1)
            }
        }()
    }
    time.Sleep(time.Second * 20)
    fmt.Println(atomic.LoadInt32(&count))
}

Go 语言并发安全的map(sync.map)

sync.Map

在Go 1.6之前,内置的map类型是部分goroutine安全的,并发的读没有问题,并发的写可能有问题。自go 1.6之后,并发地读写map会报错,这在一些知名的开源库中都存在这个问题,所以go 1.9之前的解决方案是额外绑定一个锁,封装成一个新的struct或者单独使用锁都可以。

在Go1.9之前,go自带的map不是并发安全的,也就是说,我们需要自己再封装一层,给map加上把读写锁,比如像下面这样:

type MapWithLock struct {
    sync.RWMutex
    M map[string]Kline
}

用MapWithLock的读写锁去控制map的并发安全。

但是到了Go1.9发布,它有了一个新的特性,那就是sync.map,它是原生支持并发安全的map,不过它的用法和以前我们熟悉的map完全不一样,主要还是因为sync.map封装了更为复杂的数据结构,以实现比之前加锁map更优秀的性能。

sync.map就是1.9版本带的线程安全map,主要有如下几种方法:

func (m Map) Load(key interface{}) (value interface{}, ok bool)

通过提供一个键key,查找对应的值value,如果不存在,则返回nil。ok的结果表示是否在map中找到值

func (m Map) Store(key, value interface{})

这个相当于是写map(更新或新增),第一个参数是key,第二个参数是value

func (m Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)

通过提供一个键key,查找对应的值value,如果存在返回键的现有值,否则存储并返回给定的值,如果是读取则返回true,如果是存储返回false

func (m Map) Delete(key interface{})

通过提供一个键key,删除键对应的值

func (m Map) Range(f func(key, value interface{}) bool)

循环读取map中的值。

因为for … range map是内置的语言特性,所以没有办法使用for range遍历sync.Map, 但是可以使用它的Range方法,通过回调的方式遍历。

sync.Map应用

package main

import (
    "fmt"
    "sync"
)

type userInfo struct {
    Name string
    Age  int
}

// 声明 sync.Map
var m sync.Map

func main() {
    // 写入
    m.Store(1, "one")
    m.Store("oldboy", "Go")

    // 查找
    val, ok := m.Load(1)
    fmt.Println("Load : ", val, ok) // one true

    // 查找 or 写入
    val, ok = m.LoadOrStore("oldboy", "Golang")
    fmt.Println("LoadOrStore : ", val, ok) // Go true
    val, ok = m.LoadOrStore("2", "two")
    fmt.Println("LoadOrStore : ", val, ok) // two false

    // range
    m.Range(func(k, v interface{}) bool {
        fmt.Println(k, v)
        return true
    })

    // 删除
    m.Delete(1)
    m.Delete(2)

    m.Range(func(k, v interface{}) bool {
        fmt.Println(k, v)
        return true
    })

}

相关推荐