当前位置：首页 > news >正文

GO学习之同步操作sync包

news 2025/8/16 1:34:21

GO系列

1、GO学习之Hello World
2、GO学习之入门语法
3、GO学习之切片操作
4、GO学习之 Map 操作
5、GO学习之结构体操作
6、GO学习之通道(Channel)
7、GO学习之多线程(goroutine)
8、GO学习之函数(Function)
9、GO学习之接口(Interface)
10、GO学习之网络通信(Net/Http)
11、GO学习之微框架(Gin)
12、GO学习之数据库(mysql)
13、GO学习之数据库(Redis)
14、GO学习之搜索引擎(ElasticSearch)
15、GO学习之消息队列(Kafka)
16、GO学习之远程过程调用(RPC)
17、GO学习之 goroutine的调度原理
18、GO学习之通道(nil Channel妙用)
19、GO学习之同步操作sync包

文章目录

GO系列
前言
一、channel 和 sync包
- 1.1 channel 和 sync包性能测试
- 1.2 channel 和 sync包如何选择
二、sync包使用注意事项
三、sync.Mutex 原理
四、小结

前言

按照公司目前的任务，go 学习是必经之路了，虽然行业卷，不过技多不压身，依旧努力！！！
同步操作在并发中是必不可少的的，若对一些公用的资源进行操作，为了保证操作的原子和一致性，就需要使用到锁来进行控制。
Go 语言在提供CSP（通信顺序进程）并发模型原语的的同时，还提供了标准库 sync包针对传统基于共享内存并发模型的同步原语，包括互斥锁（sync.Mutex）、读写锁（sync.RWMutex）、条件锁（sync.Cond）等。

一、channel 和 sync包

Go 语言提倡不要通过共享内存来通信，而是要通过通信来共享内存，一般的场景中，先使用 CSP 并发模型实现，就是 goroutine + channel 编程。但也有一些特殊的场景，需要 sync包提供的低级同步原语。
在 Go 中，channel 属于高级同步原语，其实现是建立在低级同步原语之上的，所以 channel 自身的性能与低级同步原语相比要稍微逊色一点了。因此，在需要需要高性能的情况下，sync包提供的低同步原语更为重要。

1.1 channel 和 sync包性能测试

我们来对 channel 和 sync包的性能做一个对比，示例代码如下（channel_sync_test.go ）：
注意！！！

基准测试代码文件必须是_test.go结尾，和单元测试一样；
基准测试的函数以Benchmark开头；
参数为 *testing.B；
基准测试函数不能有返回值；
b.ResetTimer是重置计时器，这样可以避免for循环之前的初始化代码的干扰；
b.N是基准测试框架提供的，是循环次数，无需关心；
go test -bench . .\channel_sync_test.go 运行；

package mainimport ("sync""testing"
)var data = 0// 声明互斥锁
var mu sync.Mutex// 声明一个通道
var ch = make(chan struct{}, 1)func syncByMutex() {mu.Lock()data++mu.Unlock()
}func syncByChannel() {ch <- struct{}{}data++<-ch
}// 基准测试函数以 Benchmark 开头
func BenchmarkSectionByMutex(b *testing.B) {for i := 0; i < b.N; i++ {syncByMutex()}
}// 基准测试函数以 Benchmark 开头
func BenchmarkSectionByChannel(b *testing.B) {for i := 0; i < b.N; i++ {syncByChannel()}
}

运行结果：

PS D:\workspaceGo\src\sync> go test -bench . .\channel_sync_test.go
goos: windows
goarch: amd64
cpu: Intel(R) Core(TM) i5-8300H CPU @ 2.30GHz
BenchmarkSectionByMutex-8       79662760                13.15 ns/op
BenchmarkSectionByChannel-8     27814993                40.38 ns/op
PASS
ok      command-line-arguments  2.523s

从运行结果中看，BenchmarkSectionByChannel 测试函数是 40.38 ns/op，BenchmarkSectionByMutex 是 13.15 ns/op，很明显 sync包的的性能更佳。

1.2 channel 和 sync包如何选择

同步访问 channel 的并发设计的特点是，在 goroutine 间通过 channel 转移数据对象的所有权。只有获得了数据对象的所有权（就是从 channel 中获得该对象）才可以对数据对象进行状态变更。
如果设计中没有转移结构体对象所有权，但又要保证结构体内部状态能在多个 goroutine 之间同步，那么你可以使用 sync包提供的低级同步原语来实现，比如 sync.Mutex（互斥锁）。

二、sync包使用注意事项

在 sync 包中，有这么些注释：

Values containing the types defined in this package should not be copied. （不应该包含那些包含了此包中类型的值）
A Mutex must not be copied after first use. （禁止复制首次使用后的 Mutex）

还有其他 sync包中也有诸如此类注释，那是为什么呢？我们来进行一个小 demo：

package mainimport ("log""sync""time"
)// 声明一个结构体 data
type data struct {n intsync.Mutex
}func main() {// 声明一个结构体对象 dd := data{n: 100}// 启动一个线程进行加锁操作go func(d data) {for {log.Println("go 2 try to lock...")d.Lock()log.Println("go 2 locked ok...")time.Sleep(3 * time.Second)d.Unlock()log.Println("go 2 unlock ok...")}}(d)d.Lock()log.Println("go main lock ok...")// 在 Mutex 首次使用后复制值go func(d data) {log.Println("go 1 try lock...")d.Lock()log.Println("go 1 locked ok...")time.Sleep(3 * time.Second)d.Unlock()log.Println("go 1 unlock ok...")}(d)time.Sleep(1000 * time.Second)d.Unlock()log.Println("go main unlock ok...")
}

运行结果：

PS D:\workspaceGo\src\sync> go run .\sync.go
2023/11/04 16:57:24 go main lock ok...
2023/11/04 16:57:24 go 2 try to lock...
2023/11/04 16:57:24 go 2 locked ok...
2023/11/04 16:57:24 go 1 try lock...
2023/11/04 16:57:27 go 2 unlock ok...
2023/11/04 16:57:27 go 2 try to lock...
2023/11/04 16:57:27 go 2 locked ok...
2023/11/04 16:57:30 go 2 unlock ok...
2023/11/04 16:57:30 go 2 try to lock...
2023/11/04 16:57:30 go 2 locked ok...
...

在示例中创建了两个 goroutine ：go 1 和 go 2，从运行结果中看到 go 1 阻塞在了加锁操作上了，则 go 2 则是按照预期正常运行。go 1 和 go 2 的区别就在于 go 2 是在互斥锁首次使用之前创建的，而 go 1 则是在互斥锁加锁操作并且在锁定状态之后创建的，并且程序在创建 go 1的时候复制了 data 的实例并且使用了这个副本。

三、sync.Mutex 原理

我们可以在 $GOROOT/src/sync/mutex.go 源码中看到如下声明语句：

type Mutex struct {state int32sema  uint32
}

其实 sync.Mutex 的实现很简单，定义了两个字段 state 和 sema。

state：表示当前互斥锁的状态
sema：用户控制状态的信号量

对Mutex实例的复制即是对两个整型字段的复制。在初始状态下，Mutex 示例处于 Unlocked 状态（state:0，sema：0），上述案例中，go 2 在复制了初始状态的 Mutex 实例，副本的 state 和 sema 均为 0，则与 go 2新定义的 Mutex 无异，则go 2可以继续正常运行。

后续主程序调用了 Lock 方法，Mutex 实例变为 Locked 状态，而此后 go 1 创建是恰恰复制了处于 Locked 状态的实例，那副本实例也是 Locked 状态的，所以 go 1 进去了阻塞状态（也是死锁状态，因为没有任何机会调用 Unlock 了）。