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

“纵有疾风来，人生不言弃”，这句话送给正在学习Golang的朋友们，也希望在阅读本文《怎么使用Go语言sync包与锁实现限制线程对变量的访问》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新Golang相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

本篇内容主要讲解“怎么使用Go语言sync包与锁实现限制线程对变量的访问”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“怎么使用Go语言sync包与锁实现限制线程对变量的访问”吧!

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

为什么需要锁

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

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

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

package main
import (
    "fmt"
    "time"
)
func main() {
    var a = 0
    for i := 0; i <p>从理论上来说，上面的程序会将 a 的值依次递增输出，然而实际结果却是下面这样子的。</p><blockquote><p>537<br>995<br>996<br>997<br>538<br>999<br>1000</p></blockquote><p>通过运行结果可以看出 a 的值并不是按顺序递增输出的，这是为什么呢？</p><p>协程的执行顺序大致如下所示：</p>

• 从寄存器读取 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 <p>运行结果如下：</p><blockquote><p>goroutine 995, a=996<br>goroutine 996, a=997<br>goroutine 997, a=998<br>goroutine 998, a=999<br>goroutine 999, a=1000</p></blockquote><p>需要注意的是一个互斥锁只能同时被一个 goroutine 锁定，其它 goroutine 将阻塞直到互斥锁被解锁（重新争抢对互斥锁的锁定），示例代码如下：</p><pre class="brush:go;">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 <p>上面的代码运行结果如下：</p><blockquote><p>goroutine1: 我会锁定大概 2s<br>goroutine2: 等待解锁<br>goroutine1: 我解锁了，你们去抢吧<br>goroutine2: 欧耶，我也解锁了</p></blockquote><h3>读写锁</h3><p>读写锁有如下四个方法：</p>

• 写操作的锁定和解锁分别是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 <p>其执行结果如下：</p><blockquote><p>goroutine 0 进入读操作...<br>goroutine 0 读取结束，值为：0<br>goroutine 3 进入读操作...<br>goroutine 1 进入读操作...<br>goroutine 3 读取结束，值为：0<br>goroutine 1 读取结束，值为：0<br>goroutine 4 进入写操作...<br>goroutine 4 写入结束，新值为：81<br>goroutine 4 进入读操作...<br>goroutine 4 读取结束，值为：81<br>goroutine 2 进入读操作...<br>goroutine 2 读取结束，值为：81<br>goroutine 0 进入写操作...<br>goroutine 0 写入结束，新值为：887<br>goroutine 1 进入写操作...<br>goroutine 1 写入结束，新值为：847<br>goroutine 2 进入写操作...<br>goroutine 2 写入结束，新值为：59<br>goroutine 3 进入写操作...<br>goroutine 3 写入结束，新值为：81</p></blockquote><p>下面再来看两个示例。</p><p>【示例 1】多个读操作同时读取一个变量时，虽然加了锁，但是读操作是不受影响的。（读和写是互斥的，读和读不互斥）</p><pre class="brush:go;">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

到此，相信大家对“怎么使用Go语言sync包与锁实现限制线程对变量的访问”有了更深的了解，不妨来实际操作一番吧！这里是golang学习网，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！

理论要掌握，实操不能落！以上关于《怎么使用Go语言sync包与锁实现限制线程对变量的访问》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！