go语言并发编程（二）——锁

最新推荐文章于 2024-06-13 10:18:16 发布

落雨便归尘

最新推荐文章于 2024-06-13 10:18:16 发布

阅读量973

点赞数 11

分类专栏： Go 文章标签： golang 网络开发语言后端

本文链接：https://blog.csdn.net/qq_73924465/article/details/137522517

版权

Go 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

锁

前言

在看今天的内容之前，我们先来看一个例子:

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

func main() {
	var wait sync.WaitGroup
	wait.Add(10)
	count := 0
	for i := 0; i < 10; i++ {
		go func(data *int) {
			time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))  //模拟实际耗时
			temp := *data
			ans := 1
			time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
			*data = temp + ans
			fmt.Println(*data)
			wait.Done()
		}(&count)
	}
	wait.Wait()
	fmt.Println(count)
}

输出结果为:

这和我们预期的结果并不一致，这时因为count变量作为全局变量，在并行执行的时候
多个进程会同时访问该变量，可能一个协程还没有进行完,另一个协程已经对count的值
进行了修改，导致结果不正确。我们再看下面这个例子:

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wait sync.WaitGroup
	wait.Add(2)
	count := 0
	go func() {
		defer wait.Done()
		for i := 0; i < 1000000; i++ {
			count++
		}
	}()

	go func() {
		defer wait.Done()
		for i := 0; i < 1000000; i++ {
			count--
		}
	}()

	wait.Wait()
	fmt.Println(count)
}

运行这个代码时我们会发现与我们的预期的0不一致，它的值是随机的，原因和我们上面的例子一样，
那我们如何解决这个问题？这就是我们接下来要介绍的锁了。

互斥锁

互斥锁Mutex由sync包提供，它允许我们实现对共享资源的互斥访问，我们来看一个简单的例子:

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wait sync.WaitGroup
	var lock sync.Mutex
	wait.Add(2)
	count := 0
	go func() {
		defer wait.Done()
		lock.Lock() //加锁
		for i := 0; i < 1000000; i++ {
			count++
		}
		lock.Unlock()
	}()

	go func() {
		defer wait.Done()
		lock.Lock() //解锁
		for i := 0; i < 1000000; i++ {
			count--
		}
		lock.Unlock()
	}()

	wait.Wait()
	fmt.Println(count)
}

输出结果为:

与之前的例子不同，这次我们将加和减的操作都加上了锁，这样我们就可以保证共享变量
在完成加/减操作前都不会被其他协程访问到，从而避免了数据不一致的问题。每一个协
程在访问数据前，都先上锁，更新完成后再解锁，其他协程想要访问就必须要先获得锁
否则就阻塞等待。如此一来，就不存在上述问题了。

读写锁

什么是读写锁

在介绍锁之前我们要先明确一件事情,我们要知道锁的本质其实是将原本并行的操作变成
串行操作，这样不可避免的会造成不必要的资源浪费，而在我们使用互斥锁的时候，如果
读写操作的数量趋于一致的时候，我们可以使用互斥锁，但是读写操作的数量差距较大时，
使用互斥锁将会造成大量的浪费，这时后我们就可以使用我们今天的主角——读写锁了。
对于一个协程而言:

获得读锁:当一个协程获得读锁时,其他协程进行写操作时会阻塞，其他协程进行读操
作时不会阻塞
获得写锁:当一个协程获得写锁时,其他协程进行写操作时会阻塞，其他协程进行读操作时
会阻塞

读写锁的相关方法

func(rw *sync.RWMutex) Rlock() // 读锁
func(rw *sync.RWMutex) Unlock() // 解锁
func(rw *sync.RWMutex) RUnlock() // 解锁
func(rw *sync.RWMutex) Lock() // 写锁
func(rw *sync.RWMutex) TryLock() bool // 尝试写锁
func(rw *sync.RWMutex) TryRLock() bool // 尝试读锁

读写锁的示例

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wait sync.WaitGroup
var rw sync.RWMutex
var count = 0

func main() {
	wait.Add(12)
	go func() {
		for i := 0; i < 3; i++ {
			go Write(&count)
		}
		wait.Done()
	}()
	go func() {
		for i := 0; i < 7; i++ {
			go Read(&count)
		}
		wait.Done()
	}()
	// 等待子协程结束
	wait.Wait()
	fmt.Println("最终结果", count)
}

func Read(count *int) {
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
	rw.RLock()
	fmt.Println("拿到读锁")
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
	fmt.Println("释放读锁")
	rw.RUnlock()
	defer wait.Done()
}

func Write(count *int) {
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
	rw.Lock()
	fmt.Println("拿到写锁")
	fmt.Println("拿到写锁")
	temp := *count
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000)))
	*count = temp + 1
	fmt.Println("释放写锁", *count)
	rw.Unlock()
	defer wait.Done()
}

输出

拿到读锁
拿到读锁
拿到读锁
拿到读锁
释放读锁
拿到读锁
释放读锁
释放读锁
释放读锁
释放读锁
拿到写锁
拿到写锁
释放写锁 1
拿到读锁
拿到读锁
释放读锁
释放读锁
拿到写锁
拿到写锁
释放写锁 2
拿到写锁
拿到写锁
释放写锁 3
最终结果 3

注意:对于锁而言，不应该将其作为值传递和存储，应该使用指针

条件变量

什么是条件变量

条件变量是一种用于协调并发程序中多个 goroutine 之间通信和同步的机制。它们通
常与互斥锁（Mutex）一起使用，用于在某些条件满足时唤醒等待的 goroutine。条件变量的作用包括：

等待条件满足：条件变量允许一个或多个 goroutine 等待某个条件变为真（或满足特定条件）。这个条件可能涉及到共享资源的状态变化，比如某个变量的值改变、某个事件发生等。当条件未满足时，goroutine 可以通过条件变量进入等待状态。
唤醒等待的 goroutine：当某个 goroutine 对共享资源做出修改，导致某个条件发生变化时，它可以通过条件变量来通知其他等待条件的 goroutine。这样，等待条件变为真的 goroutine 就可以被唤醒，继续执行相应的操作。
避免忙等待：在并发程序中，如果没有条件变量，某些情况下可能会出现忙等待（busy waiting），即一个 goroutine 不断地检查某个条件是否满足，这会消耗大量的 CPU 资源。条件变量可以避免这种情况，因为它允许 goroutine 在条件不满足时进入休眠状态，直到条件变为真时才被唤醒。
同步 goroutine：使用条件变量可以有效地同步多个 goroutine 的执行顺序，确保在适当的时机进行通信和处理共享资源，从而避免竞态条件和数据不一致的问题。

条件变量的组成

条件变量不是锁，它更像是是一种通信机制，在go中，条件变量由sync.Cond结构体表示，该结构体包含一个互斥锁和一个条件变量。
。它的函数签名如下:

//创建条件变量
func NewCond(l sync.Locker) *Cond
// 阻塞等待条件生效，直到被唤醒
func (c *Cond) Wait()
// 唤醒一个因条件阻塞的协程
func (c *Cond) Signal()
// 唤醒所有因条件阻塞的协程
func (c *Cond) Broadcast()

在我们创建条件变量的时候，我们需要传递一个互斥锁，这里条件变量作用的是读协
程，所以将读锁作为互斥锁传入，如果直接传入读写互斥锁会导致写协程重复解锁的问
题。这里传入的是sync.rlocker，通过RWMutex.RLocker方法获得。

func (rw *RWMutex) RLocker() Locker {
return (*rlocker)(rw)
}

type rlocker RWMutex

func (r *rlocker) Lock()   { (*RWMutex)(r).RLock() }
func (r *rlocker) Unlock() { (*RWMutex)(r).RUnlock() }

我们来看一个简单的例子:

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

var wait sync.WaitGroup
var rw sync.RWMutex
var count = 0
var cond = sync.NewCond(rw.RLocker())

func main() {
	wait.Add(12)
	for i := 0; i < 7; i++ {
		go func() {
			Read(&count)
			wait.Done()
		}()
	}
	for i := 0; i < 3; i++ {
		go func() {
			Write(&count)
			wait.Done()
		}()
	}
	wait.Wait()
	fmt.Println("最终结果:", count)
}

func Read(count *int) {
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
	fmt.Println("拿到读锁")
	rw.RLock()
	for *count < 3 {
		cond.Wait()
	}
	fmt.Println("读锁释放")
	rw.RUnlock()
	wait.Done()
}

func Write(count *int) {
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
	fmt.Println("拿到写锁")
	rw.Lock()
	temp := *count
	*count = temp + 1
	fmt.Println("写锁释放", *count)
	rw.Unlock()
	cond.Broadcast()
	wait.Done()
}

输出结果:

拿到读锁
拿到写锁
写锁释放 1
拿到写锁
写锁释放 2
拿到写锁
写锁释放 3
读锁释放
拿到读锁
读锁释放
拿到读锁
读锁释放
最终结果: 3

注意:
对于条件变量，应该使用for而不是if，应该使用循环来判断条件是否满足，因为协程被唤醒时并不能保证当前条件就已经满足了。

for *count < 3 {
	cond.Wait()
}

落雨便归尘

关注

11
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
go语言并发编程（二）——锁

在介绍锁之前我们要先明确一件事情,我们要知道锁的本质其实是将原本并行的操作变成串行操作，这样不可避免的会造成不必要的资源浪费，而在我们使用互斥锁的时候，如果读写操作的数量趋于一致的时候，我们可以使用互斥锁，但是读写操作的数量差距较大时，使用互斥锁将会造成大量的浪费，这时后我们就可以使用我们今天的主角——读写锁了。获得读锁:当一个协程获得读锁时,其他协程进行写操作时会阻塞，其他协程进行读操作时不会阻塞获得写锁:当一个协程获得写锁时,其他协程进行写操作时会阻塞，其他协程进行读操作时。
复制链接

扫一扫