Go语言sync包与锁实现限制线程对变量的访问

作者:C语言中文网 时间:2024-02-21 13:52:29 

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

为什么需要锁

锁是 sync 包中的核心,它主要有两个方法,分别是加锁(Lock)和解锁(Unlock)。

在并发的情况下,多个线程或协程同时其修改一个变量,使用锁能保证在某一时间内,只有一个协程或线程修改这一变量。

不使用锁时,在并发的情况下可能无法得到想要的结果,如下所示:

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 的值依次递增输出,然而实际结果却是下面这样子的。

537
995
996
997
538
999
1000

通过运行结果可以看出 a 的值并不是按顺序递增输出的,这是为什么呢?

协程的执行顺序大致如下所示:

  • 从寄存器读取 a 的值;

  • 然后做加法运算;

  • 最后写到寄存器。

按照上面的顺序,假如有一个协程取得 a 的值为 3,然后执行加法运算,此时又有一个协程对 a 进行取值,得到的值同样是 3,最终两个协程的返回结果是相同的。

而锁的概念就是,当一个协程正在处理 a 时将 a 锁定,其它协程需要等待该协程处理完成并将 a 解锁后才能再进行操作,也就是说同时处理 a 的协程只能有一个,从而避免上面示例中的情况出现。 

互斥锁 Mutex

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

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

将上面的代码略作修改,如下所示:

package main
import (
   "fmt"
   "sync"
   "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\n", idx, a)
       }(i)
   }
   // 等待 1s 结束主程序
   // 确保所有协程执行完
   time.Sleep(time.Second)
}

运行结果如下:

goroutine 995, a=996
goroutine 996, a=997
goroutine 997, a=998
goroutine 998, a=999
goroutine 999, a=1000

需要注意的是一个互斥锁只能同时被一个 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("goroutine2: 等待解锁")
       l.Lock()
       defer l.Unlock()
       fmt.Println("goroutine2: 欧耶,我也解锁了")
       ch <- struct{}{}
   }()
   // 等待 goroutine 执行结束
   for i := 0; i < 2; i++ {
       <-ch
   }
}

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

goroutine1: 我会锁定大概 2s
goroutine2: 等待解锁
goroutine1: 我解锁了,你们去抢吧
goroutine2: 欧耶,我也解锁了

读写锁

读写锁有如下四个方法:

  • 写操作的锁定和解锁分别是func (*RWMutex) Lock和func (*RWMutex) Unlock;

  • 读操作的锁定和解锁分别是func (*RWMutex) Rlock和func (*RWMutex) RUnlock。

读写锁的区别在于:

  • 当有一个 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", n)
    v := count
    fmt.Printf("goroutine %d 读取结束,值为:%d\n", n, v)
    rw.RUnlock()
    ch <- struct{}{}
}
func write(n int, ch chan struct{}) {
    rw.Lock()
    fmt.Printf("goroutine %d 进入写操作...\n", n)
    v := rand.Intn(1000)
    count = v
    fmt.Printf("goroutine %d 写入结束,新值为:%d\n", n, v)
    rw.Unlock()
    ch <- struct{}{}
}

其执行结果如下:

goroutine 0 进入读操作...
goroutine 0 读取结束,值为:0
goroutine 3 进入读操作...
goroutine 1 进入读操作...
goroutine 3 读取结束,值为:0
goroutine 1 读取结束,值为:0
goroutine 4 进入写操作...
goroutine 4 写入结束,新值为:81
goroutine 4 进入读操作...
goroutine 4 读取结束,值为:81
goroutine 2 进入读操作...
goroutine 2 读取结束,值为:81
goroutine 0 进入写操作...
goroutine 0 写入结束,新值为:887
goroutine 1 进入写操作...
goroutine 1 写入结束,新值为:847
goroutine 2 进入写操作...
goroutine 2 写入结束,新值为:59
goroutine 3 进入写操作...
goroutine 3 写入结束,新值为:81

下面再来看两个示例。

【示例 1】多个读操作同时读取一个变量时,虽然加了锁,但是读操作是不受影响的。(读和写是互斥的,读和读不互斥)

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")
}

运行结果如下:

1 read start
1 reading
2 read start
2 reading
1 read over
2 read over

【示例 2】由于读写互斥,所以写操作开始的时候,读操作必须要等写操作进行完才能继续,不然读操作只能继续等待。

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")
}

运行结果如下:

1 write start
3 write start
1 writing
2 read start
1 write over
2 reading

来源:http://c.biancheng.net/view/4307.html

标签:Go语言,sync包,锁
0
投稿

猜你喜欢

  • javascript面向对象三大特征之封装实例详解

    2023-08-23 21:39:04
  • linux安装mysql和使用c语言操作数据库的方法 c语言连接mysql

    2024-01-12 20:31:03
  • Python for 循环语句的使用

    2023-10-29 14:51:12
  • Pandas DataFrame 取一行数据会得到Series的方法

    2023-08-28 04:25:13
  • 教你利用pygame模块制作跳跃小球小游戏

    2022-02-07 11:28:46
  • 在脚本中单独使用django的ORM模型详解

    2021-03-09 05:17:26
  • Python OpenCV中的resize()函数的使用

    2022-03-23 23:11:56
  • 利用Python代码实现模拟动态指针时钟

    2023-12-26 14:07:50
  • 详解pyinstaller selenium python3 chrome打包问题

    2023-08-12 08:26:40
  • Python 监测文件是否更新的方法

    2022-05-11 02:37:20
  • 详解如何创建并发布一个 vue 组件

    2023-07-02 16:49:08
  • python实现PCA降维的示例详解

    2022-09-29 15:27:00
  • scrapy与selenium结合爬取数据(爬取动态网站)的示例代码

    2023-07-14 00:17:08
  • Linux如何添加mysql系统环境变量

    2024-01-24 16:27:54
  • Python面向对象之接口、抽象类与多态详解

    2021-10-24 10:26:48
  • python使用两种发邮件的方式smtp和outlook示例

    2021-02-12 13:31:54
  • keras中的loss、optimizer、metrics用法

    2022-06-15 15:53:07
  • expression为什么性能差?

    2009-05-28 19:12:00
  • 走中国特色的网站重构道路

    2010-04-08 16:10:00
  • python保存数据到本地文件的方法

    2023-10-01 20:59:53
  • asp之家 网络编程 m.aspxhome.com