Goroutine学习笔记(二)

Goroutine与锁

在进行并发编程时，很多时候都需要涉及到变量的共享，下面这段代码创建了2个Goroutine来访问变量a并对a进行自加操作，a预期结果应为200000

goroutine-without-lock.go

package main

import (
    "fmt"
    "sync"
)

func main() {
    a := 0
    var n sync.WaitGroup
    for i := 0; i < 2; i++ {
        n.Add(1)
        go func() {
            defer n.Done()
            for j := 0; j < 100000; j++ {
                a++
            }
        }()
    } //创建2个Goroutine
    n.Wait()
    fmt.Printf("a = %d\n", a)
}

大多数情况下并不能得到正确的结果

假设此时a的值为10000，那么在Goroutine [1]读取a的值后，并且未在内存中写入a加1之后的值的这段时间，如果Goroutine [2]此时访问a的值，它得到的值为10000，而不是10001，这样就造成了Goroutine [2]并没有读取到Goroutine [1]更新后的数值，因此会出现少加的情况

解决该问题的办法就是当Goroutine涉及到有关变量a的执行语句时，要确保读取和写入操作完成后其它Goroutine才能访问变量a

goroutine-with-lock.go

package main

import (
    "fmt"
    "sync"
)

func main() {
    a := 0
    var mu sync.Mutex
    var n sync.WaitGroup
    for i := 0; i < 2; i++ {
        n.Add(1)
        go func() {
            defer n.Done()
            for j := 0; j < 100000; j++ {
                mu.Lock()
                a++
                mu.Unlock()
            }
        }()
    }
    n.Wait()
    fmt.Printf("a = %d\n", a)
}

每当Goroutine执行到涉及变量a的语句时，先申请锁，更新完a的值后在释放锁，当一个Goroutine持有锁时，其它的Goroutine都会等待锁释放后再执行申请锁的操作，这样就保证了每次只有一个Goroutine执行变量a的读取和写入操作

加锁的技巧

为了避免程序运行时不必要的等待，在加锁时需要注意仅当Goroutine需要更改共享变量的值时再获取锁，更改完共享变量的值立刻释放锁

一个不恰当的例子

lock-whole-goroutine-execution_time.go

package main

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

const (
    UNASSIGN  = 0 //未分配
    COMPLETED = 1 //执行完毕
)

func main() {
    task := make([]int, 10)
    var mu sync.Mutex
    var n sync.WaitGroup
    for index := range task {
        task[index] = UNASSIGN
    }
    for index := range task {
        n.Add(1)
        go func(index int) {
            defer n.Done()
            mu.Lock()
            time.Sleep(1 * time.Second)
            task[index] = COMPLETED
            mu.Unlock() //在整个Goroutine加锁
        }(index)
    }
    n.Wait()
    fmt.Printf("All task done!\n")
}

在这个例子中，由于在整个Goroutine执行语句进行加锁，导致整个程序执行了10s，结果和串行执行所需时间一样

如果在Goroutine中等待任务完成后(time.Sleep(1 * time.Second)在此处相当于执行任务，通常情况下任务可以为I/O读写，爬虫请求等等)，再申请锁会极大的加快程序执行效率，将上面的代码time.Sleep(1 * time.Second)与mu.Lock()互换位置再执行，整个程序仅需1s就可以执行完毕

上述代码其实不适用sync.WaitGroup也可以实现等待操作，主要思想就是通过循环遍历检查所有的任务是否执行完毕，如果所有任务执行完毕退出循环

lock-without-waitgroup.go

package main

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

const (
    UNASSIGN  = 0 //未分配
    COMPLETED = 1 //执行完毕
)

func main() {
    task := make([]int, 10)
    var mu sync.Mutex
    for index := range task {
        task[index] = UNASSIGN
    }
    for index := range task {
        go func(index int) {
            time.Sleep(1 * time.Second)
            mu.Lock()
            task[index] = COMPLETED
            mu.Unlock()
        }(index)
    }

    for {
        taskDone := true
        for index := range task {
            taskDone = taskDone && (task[index] == COMPLETED)
        } //当所有任务执行完毕时，taskDone为true
        if taskDone {
            break
        } //当所有任务执行完毕时，退出循环
    }
    fmt.Printf("All task done!\n")
}

上面的代码还可以优化一下，由于使用的是for {}语句，会一直占用CPU，为了避免其一直占用CPU，在for循环内部可以添加time.Sleep(100 * time.Millisecond)