• gmutex
    • 基准测试
    • 示例1，基本使用
    • 示例2，*Func使用

    gmutex

    gmutex模块是基于atomic + channel实现的高级互斥锁模块，支持更丰富的互斥锁特性。

    gmutex.Mutex互斥锁对象支持读写控制，互斥锁功能逻辑与标准库sync.RWMutex类似，可并发读但不可并发写。

    互斥锁的设计细节，推荐阅读轻量级高清版的实现源码：https://github.com/gogf/gf/blob/master/g/os/gmutex/gmutex.go

    使用方式：

    1. import "github.com/gogf/gf/g/os/gmutex"

    接口文档：

    https://godoc.org/github.com/gogf/gf/g/os/gmutex

    1. type Mutex
    2.     func New() *Mutex
    3.     func (m *Mutex) IsLocked() bool
    4.     func (m *Mutex) IsRLocked() bool
    5.     func (m *Mutex) IsWLocked() bool
    6.     func (m *Mutex) Lock()
    7.     func (m *Mutex) LockFunc(f func())
    8.     func (m *Mutex) RLock()
    9.     func (m *Mutex) RLockFunc(f func())
    10.     func (m *Mutex) RUnlock()
    11.     func (m *Mutex) TryLock() bool
    12.     func (m *Mutex) TryLockFunc(f func()) bool
    13.     func (m *Mutex) TryRLock() bool
    14.     func (m *Mutex) TryRLockFunc(f func()) bool
    15.     func (m *Mutex) Unlock()
    1. 该互斥锁模块最大的特点是支持Try*方法以及*Func方法。
    2. Try*方法用于实现尝试获得特定类型的锁，如果获得锁成功则立即返回true，否则立即返回false，不会阻塞等待，这对于需要使用非阻塞锁机制的业务逻辑非常实用。
    3. *Func方法使用闭包匿名函数的方式实现特定作用域的并发安全锁控制，这对于特定代码块的并发安全控制特别方便，由于内部使用了defer来释放锁，因此即使函数内部产生异常错误，也不会影响锁机制的安全性控制。

    基准测试

    gmutex.Mutex与标准库的sync.Mutex及sync.RWMutex的基准测试对比结果：gmutex_bench_test.go

    1. goos: darwin
    2. goarch: amd64
    3. pkg: github.com/gogf/gf/g/os/gmutex
    4. Benchmark_Mutex_LockUnlock-4           50000000            31.5 ns/op
    5. Benchmark_RWMutex_LockUnlock-4         30000000            54.1 ns/op
    6. Benchmark_RWMutex_RLockRUnlock-4       50000000            27.9 ns/op
    7. Benchmark_GMutex_LockUnlock-4          50000000            27.2 ns/op
    8. Benchmark_GMutex_TryLock-4             100000000           16.7 ns/op
    9. Benchmark_GMutex_RLockRUnlock-4        50000000            38.0 ns/op
    10. Benchmark_GMutex_TryRLock-4            100000000           16.8 ns/op

    示例1，基本使用

    1. package main
    3. import (
    4.     "time"
    6.     "github.com/gogf/gf/g/os/glog"
    7.     "github.com/gogf/gf/g/os/gmutex"
    8. )
    10. func main() {
    11.     mu := gmutex.New()
    12.     for i := 0; i < 10; i++ {
    13.         go func(n int) {
    14.             mu.Lock()
    15.             defer mu.Unlock()
    16.             glog.Println("Lock:", n)
    17.             time.Sleep(time.Second)
    18.         }(i)
    19.     }
    20.     for i := 0; i < 10; i++ {
    21.         go func(n int) {
    22.             mu.RLock()
    23.             defer mu.RUnlock()
    24.             glog.Println("RLock:", n)
    25.             time.Sleep(time.Second)
    26.         }(i)
    27.     }
    28.     time.Sleep(11 * time.Second)
    29. }

    执行后，终端输出：

    1. 2019-07-13 16:19:55.417 Lock: 0
    2. 2019-07-13 16:19:56.421 Lock: 1
    3. 2019-07-13 16:19:57.424 RLock: 0
    4. 2019-07-13 16:19:57.424 RLock: 4
    5. 2019-07-13 16:19:57.425 RLock: 8
    6. 2019-07-13 16:19:57.425 RLock: 2
    7. 2019-07-13 16:19:57.425 RLock: 7
    8. 2019-07-13 16:19:57.425 RLock: 5
    9. 2019-07-13 16:19:57.425 RLock: 9
    10. 2019-07-13 16:19:57.425 RLock: 1
    11. 2019-07-13 16:19:57.425 RLock: 6
    12. 2019-07-13 16:19:57.425 RLock: 3
    13. 2019-07-13 16:19:58.429 Lock: 3
    14. 2019-07-13 16:19:59.433 Lock: 4
    15. 2019-07-13 16:20:00.438 Lock: 5
    16. 2019-07-13 16:20:01.443 Lock: 6
    17. 2019-07-13 16:20:02.448 Lock: 7
    18. 2019-07-13 16:20:03.452 Lock: 8
    19. 2019-07-13 16:20:04.456 Lock: 9
    20. 2019-07-13 16:20:05.461 Lock: 2

    这里使用glog打印的目的，是可以方便地看到打印输出的时间。可以看到，在第3秒的时候，读锁抢占到了机会，由于gmutex.Mutex对象支持并发读但不支持并发写，因此读锁抢占后迅速执行完毕；而写锁依旧保持每秒打印一条日志继续执行。

    示例2，*Func使用

    1. package main
    3. import (
    4.     "time"
    6.     "github.com/gogf/gf/g/os/glog"
    8.     "github.com/gogf/gf/g/os/gmutex"
    9. )
    11. func main() {
    12.     mu := gmutex.New()
    13.     go mu.LockFunc(func() {
    14.         glog.Println("lock func1")
    15.         time.Sleep(1 * time.Second)
    16.     })
    17.     time.Sleep(time.Millisecond)
    18.     go mu.LockFunc(func() {
    19.         glog.Println("lock func2")
    20.     })
    21.     time.Sleep(2 * time.Second)
    22. }

    执行后，终端输出：

    1. 2019-07-13 16:28:10.381 lock func1
    2. 2019-07-13 16:28:11.385 lock func2

    可以看到，使用*Func方法实现特定作用域的锁控制非常方便。