1. 内存锁，支持按照给定键名生成内存锁，并支持Try*Lock及锁过期特性；
  2. Mutex 对标准库底层sync.Mutex的封装，增加了Try*Lock特性；

使用方式：

使用场景：

  1. 任何需要并发安全的场景，可以替代sync.Mutex；
  2. 需要使用Try*Lock的场景(不需要阻塞等待锁释放)；
  3. 需要动态创建互斥锁，或者需要维护大量动态锁的场景；

方法列表

  1. func Lock(key string, expire ...int)
  2. func RLock(key string, expire ...int)
  3. func RUnlock(key string)
  4. func TryLock(key string, expire ...int) bool
  5. func TryRLock(key string, expire ...int) bool
  6. func Unlock(key string)
  7. type Locker
  8.     func New() *Locker
  9.     func (l *Locker) Lock(key string, expire ...int)
  10.     func (l *Locker) RLock(key string, expire ...int)
  11.     func (l *Locker) RUnlock(key string)
  12.     func (l *Locker) TryLock(key string, expire ...int) bool
  13.     func (l *Locker) TryRLock(key string, expire ...int) bool
  14.     func (l *Locker) Unlock(key string)
  15. type Mutex
  16.     func NewMutex() *Mutex
  17.     func (l *Mutex) Lock()
  18.     func (l *Mutex) RLock()
  19.     func (l *Mutex) RUnlock()
  20.     func (l *Mutex) TryLock() bool
  21.     func (l *Mutex) TryRLock() bool
  22.     func (l *Mutex) Unlock()

示例1，基本使用

  1. package main
  3. import (
  4.     "time"
  5.     "sync"
  6.     "gitee.com/johng/gf/g/os/glog"
  7.     "gitee.com/johng/gf/g/os/gmlock"
  8. )
  10. func main() {
  11.     key := "lock"
  12.     wg  := sync.WaitGroup{}
  13.     for i := 0; i < 10; i++ {
  14.         wg.Add(1)
  15.         go func(i int) {
  16.             gmlock.Lock(key)
  17.             glog.Println(i)
  18.             gmlock.Unlock(key)
  19.             wg.Done()
  21.     }
  22.     wg.Wait()
  23. }

该示例中，模拟了同时开启10个goroutine，但同一时刻只能有一个goroutine获得锁，获得锁的goroutine执行1秒后退出，其他goroutine才能获得锁。

执行后，输出结果为：

  1. 2018-10-15 23:57:28.295 9
  2. 2018-10-15 23:57:29.296 0
  3. 2018-10-15 23:57:30.296 1
  4. 2018-10-15 23:57:31.296 2
  5. 2018-10-15 23:57:32.296 3
  6. 2018-10-15 23:57:33.297 4
  7. 2018-10-15 23:57:34.297 5
  8. 2018-10-15 23:57:35.297 6
  9. 2018-10-15 23:57:36.298 7
  10. 2018-10-15 23:57:37.298 8

示例2，过期控制

执行后，输出结果为：

  1. 2018-10-15 23:59:14.663 9
  2. 2018-10-15 23:59:15.663 4
  3. 2018-10-15 23:59:16.663 0
  4. 2018-10-15 23:59:17.664 1
  5. 2018-10-15 23:59:18.664 2
  6. 2018-10-15 23:59:19.664 3
  7. 2018-10-15 23:59:20.664 6
  8. 2018-10-15 23:59:21.664 5
  9. 2018-10-15 23:59:22.665 7
  10. 2018-10-15 23:59:23.665 8

示例3，TryLock非阻塞锁

TryLock方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true；如果获取失败（即锁已被其他goroutine获取），则返回false。

  1. package main
  3. import (
  4.     "sync"
  5.     "gitee.com/johng/gf/g/os/glog"
  6.     "time"
  7.     "gitee.com/johng/gf/g/os/gmlock"
  8. )
  10. func main() {
  11.     key := "lock"
  12.     wg  := sync.WaitGroup{}
  13.     for i := 0; i < 10; i++ {
  14.         wg.Add(1)
  15.         go func(i int) {
  16.             if gmlock.TryLock(key) {
  17.                 glog.Println(i)
  18.                 time.Sleep(time.Second)
  19.                 gmlock.Unlock(key)
  20.             } else {
  21.                 glog.Println(false)
  22.             }
  23.             wg.Done()
  24.     }
  26. }

同理，在该示例中，同时也只有1个goroutine能获得锁，其他goroutine在TryLock失败便直接退出了。

执行后，输出结果为：

  1. 2018-10-16 00:01:59.172 9
  2. 2018-10-16 00:01:59.172 false
  3. 2018-10-16 00:01:59.172 false
  4. 2018-10-16 00:01:59.172 false
  5. 2018-10-16 00:01:59.172 false
  6. 2018-10-16 00:01:59.172 false
  7. 2018-10-16 00:01:59.172 false
  8. 2018-10-16 00:01:59.172 false
  9. 2018-10-16 00:01:59.172 false
  10. 2018-10-16 00:01:59.176 false

示例4，多个锁机制冲突

执行后，输出结果为：

  1. 2018-10-16 00:03:40.277 lock1
  2. 2018-10-16 00:03:40.279 unlock1
  4. 2018-10-16 00:03:40.279 lock2
  5. 2018-10-16 00:03:43.279 unlock2
  6. 2018-10-16 00:03:43.279 lock by goroutine

示例5，多文件并发写的安全控制

在glog模块写日志文件的时候有这么一个核心方法，我们拿来看一下（源代码位于 /g/os/glog/glog_logger.go）。

  1. // 这里的写锁保证同一时刻只会写入一行日志，防止串日志的情况
  2. func (l *Logger) print(std io.Writer, s string) {
  3.     // 优先使用自定义的IO输出
  4.     if l.printHeader.Val() {
  5.         s = l.format(s)
  6.     }
  7.     writer := l.GetWriter()
  8.     if writer == nil {
  9.         // 如果设置的writer为空，那么其次判断是否有文件输出设置
  10.         // 内部使用了内存锁，保证在glog中对同一个日志文件的并发写入不会串日志(并发安全)
  11.         if f := l.getFilePointer(); f != nil {
  12.             defer f.Close()
  13.             key := l.path.Val()
  14.             gmlock.Lock(key)
  15.             _, err := io.WriteString(f, s)
  16.             gmlock.Unlock(key)
  17.             if err != nil {
  18.                 fmt.Fprintln(os.Stderr, err.Error())
  19.             }
  20.         }
  21.     } else {
  22.         l.doStdLockPrint(writer, s)
  23.     }
  24.     // 是否允许输出到标准输出
  25.     if l.alsoStdPrint.Val() {
  26.         l.doStdLockPrint(std, s)
  27.     }
  28. }

其中的：

  1. gmlock.Lock(key)
  2. ...

便使用到了内存锁的特性，其中的变量key表示的是日志文件的，当多个goroutine对同一个日志文件进行写入时，由gmlock.Lock(key)来保证对该文件的并发安全写操作。