互斥锁

  • sync.mutex
  • 获取到锁的任务，阻塞其他任务
  • 意味着同一时间只有一个go才能持有锁
  • 互斥锁举例 ```go package main

import ( “log” “sync” “time” )

var HcMutex sync.Mutex

func runMutex(id int) { log.Printf(“[任务id:%d][尝试获取锁]”, id) HcMutex.Lock() log.Printf(“[任务id:%d][获取到了锁][开始干活:睡眠10秒]”, id) time.Sleep(10 * time.Second) HcMutex.Unlock() log.Printf(“[任务id:%d][干完活了 释放锁]”, id) }

func runHcLock() { go runMutex(1) go runMutex(2) go runMutex(3) }

func main() { // 执行互斥锁 效果任务 runHcLock()

  1. time.Sleep(600 * time.Second)  //演示使用，目的是不让主线程延迟退出

}

  1. <a name="kwcAP"></a>
  2. ## **读写锁**
  4. - sync.rwmutex
  5. - 写锁阻塞所有锁(所有读锁和写锁)  ，目的是修改时其他人不要读取，也不要修改
  6. - 读锁阻塞写锁 ，读锁可以同时施加多个 。目的 不要让修改数据影响我的读取结果
  7.    - 同时多个读任务， 可以施加多个读锁，阻塞写锁
  8.    - 同时多个写任务 ，只可以施加一个写锁，阻塞其他所有锁 ，退化成互斥锁
  9.    - 读写混合：若有写锁，等待释放后能施加 读或写
  10.    - 读写混合：若有读锁，只能再施加读锁，阻塞写锁
  12. ```go
  13. package main
  15. import (
  16.     "log"
  17.     "sync"
  18.     "time"
  19. )
  21. var HcMutex sync.Mutex
  22. var rwMutex sync.RWMutex
  24. func runMutex(id int) {
  25.     log.Printf("[任务id:%d][尝试获取锁]", id)
  26.     HcMutex.Lock()
  27.     log.Printf("[任务id:%d][获取到了锁][开始干活:睡眠10秒]", id)
  28.     time.Sleep(10 * time.Second)
  29.     HcMutex.Unlock()
  30.     log.Printf("[任务id:%d][干完活了 释放锁]", id)
  31. }
  32. func runHcLock() {
  33.     go runMutex(1)
  34.     go runMutex(2)
  35.     go runMutex(3)
  36. }
  38. func runReadLock(id int) {
  39.     log.Printf("[读任务:%d][进入读方法等待获取读锁]", id)
  40.     rwMutex.RLock()
  41.     log.Printf("[读任务:%d][获取到了读锁][干活:睡眠10秒]", id)
  42.     time.Sleep(10 * time.Second)
  43.     rwMutex.RUnlock()
  44.     log.Printf("[读任务:%d][完成读任务，释放读锁]",id)
  45. }
  47. func runWriteLock(id int) {
  48.     log.Printf("[写任务:%d][进入写方法等待获取写锁]", id)
  49.     rwMutex.Lock()
  50.     log.Printf("[写任务:%d][获取到了写锁][干活:睡眠10秒]", id)
  51.     time.Sleep(10 * time.Second)
  52.     rwMutex.Unlock()
  53.     log.Printf("[写任务:%d][完成写任务，释放写锁]",id)
  54. }
  56. func allWriteWorks() {
  57.     for i := 1; i < 6; i++ {
  58.         go runWriteLock(i)
  59.     }
  60. }
  62. func allReadWorks() {
  63.     for i := 1; i < 6; i++ {
  64.         go runReadLock(i)
  65.     }
  66. }
  68. func writeFirst() {
  69.     go runWriteLock(1)
  70.     time.Sleep(1 * time.Second)
  71.     go runReadLock(1)
  72.     go runReadLock(2)
  73.     go runReadLock(3)
  74.     go runReadLock(4)
  75.     go runReadLock(5)
  76. }
  78. func readFirst() {
  79.     go runReadLock(1)
  80.     go runReadLock(2)
  81.     go runReadLock(3)
  82.     go runReadLock(4)
  83.     go runReadLock(5)
  84.     time.Sleep(1 * time.Second)
  85.     go runWriteLock(1)
  86. }
  88. func main() {
  89.     // 执行互斥锁 效果任务
  90.     //runHcLock()
  92.     // 同时多个写锁任务，说明如果 并非使用 读写锁的写锁任务时，退化成了互斥锁
  93.     //allWriteWorks()
  95.     // 同时并发 读锁任务， 说明读写锁的读锁 是可以同时施加多个读锁的
  96.     //allReadWorks()
  98.     // 先启动写锁任务，后并非5个读锁任务，当有写锁时，读锁施加不了，写锁释放完，读锁可以施加多个
  99.     //writeFirst()
  101.     // 并发5个读锁任务，启动一个写锁任务， 当有读锁时，阻塞写锁
  102.     readFirst()
  104.     time.Sleep(6000 * time.Second)
  105. }