网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go 锁的使用

2020-06-10 03:00:09 admin 488

## 锁

### 互斥锁

__
由标准库代码包sync中的Mutex结构体类型代表，sync.Mutex类型（确切地说，是*sync.Mutex类型）只有两个公开方法——Lock和Unlock。顾名思义，前者被用于锁定当前的互斥量，而后者则被用来对当前的互斥量进行解锁。

package main
    
    import (
        "sync"
        "fmt"
        "runtime"
        "time"
    )
    type Accout struct {
        flag sync.Mutex         //sync.Mutex类型
        money int
    }
    //进行买的操作
    func (a *Accout) Buy(n int) {  //自己买的工资
        a.flag.Lock()           //锁上
        defer a.flag.Unlock()   //在方法运行完之后解开
        if a.money >n {
            a.Do_Prepare()
            a.money -= n
        }else {
            fmt.Println("您自己买的余额已不足！请及时充值~")
        }
    }
    //交易操作
    func (a *Accout) Do_Prepare()  {
        fmt.Println("您的余额充足可以进行交易")
    }
    //工资添加
    func (a *Accout) Add_Money(m int)  {
        a.flag.Lock()           //锁上
        defer a.flag.Unlock()   //在方法运行完之后解开
        a.money+=m
        fmt.Println("添加money",m)
    }
    func main() {
        runtime.GOMAXPROCS(runtime.NumCPU())
        aa:=Accout{*new(sync.Mutex),100}
        for i:=0; i<5;i++  {
            go aa.Buy(50)
            go aa.Add_Money(20)
        }
        time.Sleep(time.Millisecond)
    }

### 读写锁

__ 读写锁由结构体类型sync.RWMutex代表。它可以分别针对读操作和写操作进行锁定和解锁操作。

* 注：

__ 1、多个读之间不存在互斥关系

__ 2、写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的

#### 读===》

var m *sync.RWMutex  //定义m的类型为读写锁。
    m.RLock()  //读锁定
    m.RUnlock() //读解锁

读的时候随便读

package main
    
    import (
        "sync"
        "time"
    )
    
    var m *sync.RWMutex
    
    func main() {
        m = new(sync.RWMutex)
        
        // 多个同时读
        go read(1)
        go read(2)
    
        time.Sleep(2*time.Second)
    }
    
    func read(i int) {
        println(i,"read start")
    
        m.RLock()
        println(i,"reading")
        time.Sleep(1*time.Second)
        m.RUnlock()    
    
        println(i,"read over")
    }

#### 写===》

var m *sync.RWMutex  //定义m的类型为读写锁。
    m.Lock() //写操作锁定
    m.Unlock()  //写操作解锁

写的时候啥也不能做

package main
    
    import (
        "sync"
        "time"
    )
    
    var m *sync.RWMutex
    
    func main() {
        m = new(sync.RWMutex)
        
        // 写的时候啥也不能干
        go write(1)
        go read(2)
        go write(3)
    
        time.Sleep(2*time.Second)
    }
    
    func read(i int) {
        println(i,"read start")
    
        m.RLock()
        println(i,"reading")
        time.Sleep(1*time.Second)
        m.RUnlock()    
    
        println(i,"read over")
    }
    
    func write(i int) {
        println(i,"write start")
    
        m.Lock()
        println(i,"writing")
        time.Sleep(1*time.Second)
        m.Unlock()
    
        println(i,"write over")
    }

### wait group

__
WaitGroup在go语言中，用于线程同步，它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。

__ **注**

阻塞主线程等goroutine执行完之后再放开

例

定义：
    wg := new(sync.WaitGroup) //定义一个WaitGroup，就是用来等待都
    添加几个协程:
    wg.Add(2) //有几个进程需要等待就写几个，写多或写少都会报错哟～
    运行某个协程：
        go func() {
            wg.Done() //该进程结束就发送结束标志。
        }()
    标记所有协程执行完毕
    wg.Wait()  //等待所有协程结束后在执行以下都代码。

转载文章，原文链接： go 锁的使用

关键字词go 使用

分享到：

上一篇：golang MD5实现

下一篇：go 进程和线程

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go 锁的使用

admin 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go 锁的使用

admin 官方 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

admin 1年前