★sync | 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)
}