同步与并发
★sync | sync 包提供了互斥锁这类的基本的同步原语.
1. sync包定义了锁接口Locker：只要可以上锁解锁的结构都是锁（只要嘎嘎叫的都是鸭子
// A Locker represents an object that can be locked and unlocked.
type Locker interface {
Lock()
Unlock()
}
2. sync中实现了本接口的基本锁有Mutex和RWMutex，还有一个noCopy的唯一锁
- Mutex：互斥锁，一个变量只允许一个代码段进行操作
- WRMutex：读写锁，一个变量可以并发读，但只能串行写
- noCopy: 这个神奇的锁定义如下：
noCopy may be embedded into structs which must not be copied after the first use.
3. sync里还定义了高级点的锁：
Cond：条件锁，需要传入一个基本锁，使用方式如下：
新建：
cond := sync.NewCond(&sync.Mutex{})
使用：
go func() {
cond.L.Lock()
defer cond.L.Unlock()
cond.Wait()
// 临界区.....
}()
唤醒：
函数会阻塞在Wait函数（内部会cond.L.Unlock()所以可以阻塞多个函数），有如下两种唤醒方法：
-
cond.Signal()：唤醒当前等待队列里第一个 -
cond.Broadcast()：顺序唤醒当前等待队列里所有阻塞函数，唤醒期间阻塞的函数无法加入阻塞队列
WaitGroup：很常用了，Wait直到所有Add都Done了，可以等待所有子线程结束后才将主函数结束
Add就是控制变量加x，Done就是控制变量减1，Wait就是直到控制变量为0才结束，有操作系统基础的话，理解很容易
var goroutineGuard sync.WaitGroup
goroutineGuard.Add(1000)
for i := 0; i < 1000; i++ {
i:=i
go func() {
defer goroutineGuard.Done()
fmt.Println(i)
time.Sleep(time.Millisecond*100)
}
}
goroutineGuard.Wait()
4. 另外，sync也定义了某些比较安全的结构：Map,Once,Pool
这些结构可以抵抗并发导致的同步问题，测试代码如下：
Map
这里的k,v都是interface{}空接口类型的
func secureMap() {
var secureMap sync.Map
for i := 0; i < 100; i++ {
i:=i
go func() {
secureMap.Store(i, i)
}()
}
secureMap.Range(func(key, value interface{}) bool {
fmt.Println(key, "->", value)
// return false mean dont traversal
return false
})
}
Once
func OnceLock() {
var once sync.Once
for i := 0; i < 10; i++ {
once.Do(func() {
fmt.Println("print once")
})
}
}
Pool
属于一个快增慢减的连接池
-
pool.Get()的意思就是从pool中获取一个空闲连接，但若pool中没有可用的连接，将会调用pool.New()方法新建一个连接 -
pool.Put()的意思为这个连接用完了，把它放回pool中（变成空闲连接），但在放回过程中有25%的概率（证据：if fastrand()%4 == 0）销毁本连接
var ConnCount int
var ConnCountGuard sync.Mutex
func NewConn() *Conn {
// 模拟新建链接
ConnCountGuard.Lock()
defer ConnCountGuard.Unlock()
ConnCount++
return &Conn{ConnCount}
}
type Conn struct{ id int}
func (c *Conn) Write(obj ...interface{}) {
fmt.Println("Conn",c.id,":",obj)
}
func Pool() {
pool := sync.Pool{New: func() interface{} {
//this func used to get a new connect
return NewConn()
}}
for i := 0; i < 20; i++ {
go func(i int) {
cursor := pool.Get().(*Conn)
defer pool.Put(cursor)
cursor.Write("I'm ",i)
}(i)
}
time.Sleep(time.Second)
fmt.Println(ConnCount)
}
有疑问加站长微信联系（非本文作者）
