golang并发与锁

本文我们来学习一下golang里面的并发以及golang的锁机制。

首先我们假设这样一个场景，有两个协程，同时在读写一个数字，分别对其进行递增和递减，代码如下。

func main(){
    a := 1
    p_a := &a
    go func(p_a *int){
        for i := 1; i < 100000; i++ {
            *p_a += 1
            fmt.Println(*p_a)
        }
    }(p_a)
    go func(p_a *int){
        for i := 1; i < 100000; i++ {
            *p_a -= 1
            fmt.Println(*p_a)
        }
    }(p_a)
}

运行这段代码我们发现什么都没有输出，原因很简单，主程序在创建完两个协程之后就退出了。要想让主程序不退出可以使用sync.WaitGroup

func main(){
  a := 1;
  p_a := &a;
  var wg sync.WaitGroup
  wg.Add(2)
  go func(p_a *int){
    for i := 1; i < 100000; i++ {
      *p_a += 1
    }
    wg.Done()
  }(p_a)
  go func(p_a *int){
    for i := 1; i < 100000; i++ {
      *p_a -= 1  
    }
    wg.Done()
  }(p_a)
  wg.Wait()
  fmt.Println(*p_a)
}

然而，程序跑出来的结果并不是1，而且每次跑出来的都不一样。其实，写过一点并发的同学都知道原因。假设当前变量值为1，协程a试图对其加1，于是协程a首先对其进行读操作，得到1，并加1得到2，但是在2这个值被写回变量之前，协程b读取了变量，而此时变量依旧还是1，于是b拿到这个1并减一得到0。这时候，无论协程1先完成写回还是协程b先完成写回，我们得到的结果都是错的。
要想得到正确的结果，一个最常用的方法就是加锁。在golang里面，我们可以使用sync.Mutex

var l sync.Mutex

func main(){
  a := 1;
  p_a := &a;
  var wg sync.WaitGroup
  wg.Add(2)
  go func(p_a *int){
    for i := 1; i < 100000; i++ {
      l.Lock()
      *p_a += 1
      l.Unlock()
    }
    wg.Done()
  }(p_a)
  go func(p_a *int){
    for i := 1; i < 100000; i++ {
      l.Lock()
      *p_a -= 1
      l.Unlock()
    }
    wg.Done()
  }(p_a)
  wg.Wait()
  fmt.Println(*p_a)
}

golang里面的map

当一个协程在写map的时候，其他协程如果试图去读或者写这个map，程序都会直接crash!!!很多人都在吐槽这个设计，但是我觉得，这种设计至少给了程序员立即发现问题的机会。加锁吧少年。

死锁，活锁与饥饿

死锁可以理解为完成一项任务的资源被两个（或多个）不同的协程分别占用了，导致它们全都处于等待状态不能完成下去。

活锁的例子是两个或多个协程在执行时分别占用了部分资源导致无法执行。于是他们都释放资源并重新请求，可是依旧碰撞，导致仍然无法执行。

饥饿的例子是如果事务T1封锁了数据R,事务T2又请求封锁R，于是T2等待。T3也请求封锁R，当T1释放了R上的封锁后，系统首先批准了T3的请求，T2仍然等待。然后T4又请求封锁R，当T3释放了R上的封锁之后，系统又批准了T4的请求......T2可能永远等待。

有疑问加站长微信联系（非本文作者）