sync包提供了基本的同步基元，如互斥锁。除了Once和WaitGroup类型，大部分都是适用于低水平程序线程，高水平的同步使用channel通信更好一些。
本包的类型的值不应被拷贝
- Once 只执行一次操作
- 互斥锁
- 读取写入锁
Once 只执行一次操作
func (o *Once) Do(f func())
注意f是没有参数的函数
package main
import (
"fmt"
"sync"
)
func main() {
do := func() {
fmt.Println("这个函数只被执行一次")
}
// 定义一个结构体
var once sync.Once
for i:=0;i<10;i {
// 只执行一次
once.Do(do)
fmt.Println(i)
}
}下面的do会被执行几次?执行的是结果是什么?
代码语言：javascript复制package main
import (
"fmt"
"sync"
)
func main() {
var i = 0
do := func() {
fmt.Println("这个函数只被执行一次")
}
// 定义一个结构体
var once sync.Once
for i=0;i<100;i {
// 只执行一次
go once.Do(do)
do = func() {
println(i)
}
}
}答案 执行一次,执行的结果不确定,因为函数是指针类型,所以执行do方法的时候,不能确定当时有没有被重新赋值
代码语言：javascript复制package main
import (
"fmt"
"sync"
)
func main() {
var i = 0
do := func( i int) {
fmt.Println("这个函数只被执行一次",i)
}
// 定义一个结构体
var once sync.Once
for i=0;i<100;i {
// 只执行一次
go once.Do(func() {
do(i)
})
}
}下面的输出结果是什么?
代码语言：javascript复制package main
import (
"fmt"
"sync"
)
func main() {
var i = 0
// 定义一个结构体
var once sync.Once
do := func() {
fmt.Println("这个函数只被执行一次",i)
}
for i=0;i<100;i {
// 只执行一次
go once.Do(func() {
// 已经被调用了不会再调用,所以不会出现任何结果
once.Do(do)
})
}
}互斥锁
为什么要使用互斥锁,先看下面一个例子
代码语言：javascript复制package main
import (
"fmt"
"time"
)
func main() {
var count = 0
for i:=0;i<1000;i {
// 只执行一次
go func() {
count
}()
}
time.Sleep(time.Second)
fmt.Println(count)
}
image.png
cup运算单元对count进行运算的时候,分为从内存单元读取数据,执行运算,再把结果写会到原来的地址,多个协程对count产生竞争,导致计算结果出现了偏差
下面我们就使用加锁,让单个协程处理count计算的时候,其他协程对count进行任何操作,主要保证count的计算过程不能被分割,要让程序一次执行完计算读取,计算,写入三个步骤
代码语言：javascript复制package main
import (
"fmt"
"time"
"sync"
)
func main() {
var count = 0
var mutex sync.Mutex
for i:=0;i<1000;i {
// 只执行一次
go func() {
mutex.Lock()
count
mutex.Unlock()
// 其他操作不受影响
}()
}
time.Sleep(time.Second)
fmt.Println(count)
}
image.png
经过上面的互斥锁，我们的结果就不会出错了
读取写入锁
- 读取的时候,不允许写入,单不影响写入
