互斥量(锁) 在go语言里面很少用，但是也提供支持 ！

互斥量的概念！go语言提供的锁：Mutex (sync.Mutex)

go 语言提供了原子类型的操作，在 sync/atomic 包下
比如 atomic.AddInt32() 就是累加操作， go 语言提供的
累加操作，就算多个协程同时累加，也是安全，优先使用 go 语言提供的！

在这里手动实现一个互斥量, 用来实现 累加操作

package main

import (
    "fmt"
    "sync"
    "time"
)

/**
    互斥量的概念！go语言提供的锁：Mutex (sync.Mutex)

    // go 语言提供了原子类型的操作，在 sync/atomic 包下
    // 比如 atomic.AddInt32() 就是累加操作

    累加操作，就算多个协程同时累加，也是安全，优先使用 go 语言提供的！


    在这里手动实现一个互斥量, 用来实现 累加操作

*/

/**
由于 会出现我在写的时候，另一个人却在读，导致冲突, 所以进行改写
 */
// 声明一个 int 类型
// type atomicInt int

// 获取值
//func (a *atomicInt) get() int {
//  // 返回值，包装一下，就不会返回地址
//  return int(a)
//}

/**
    改写后
 */

type atomicInt struct {
    value int
    lock sync.Mutex // 互斥锁, 也就是我正在操作的时候，我排斥其他人操作
}

// 加一 操作
func (a *atomicInt) increment() {
    // 在写的时候，进行上锁保护, 防止读写冲突
    a.lock.Lock()
    // 释放锁， 执行完毕后我就释放锁
    defer a.lock.Unlock()
    a.value ++

}

// 获取值
func (a *atomicInt) get() int {
    // 返回值，包装一下，就不会返回地址
    // 上锁
    a.lock.Lock()
    // 释放锁, 读完后我释放锁
    defer a.lock.Unlock()
    return a.value
}

func main() {
    var a atomicInt
    a.increment()
    go func() {
        a.increment()
    }()

    /**
        这个时候会有一个问题，就是我 a 正在写的时候，另一个却正在读这个 a，导致冲突！
        改写后就解决了这个问题！
     */

    time.Sleep(time.Millisecond)
    fmt.Println(a.get())


}