闭包,sync使用细节

代码

先看代码以下：

func main() {
    var a []int
    for i := 0; i < 100; i++ {
        go func() {
            a = append(a, i)
        }()
    }
    time.Sleep(2 * time.Second)
    fmt.Println(a)
}

这段测试代码是想要一个元素为0到100的切片，可是这一小段代码隐藏了不少的问题。

闭包函数

先看这段代码的执行结果：

[10 12 13 13 13 13 21 24 25 28 28 28 28 28 28 29 29 29 36 38 39 39 40 41 41 41 41 41 41 45 45 45 45 46 47 48 49 50 51 52 61 61 61 61 61 61 61 61 61 61 73 73 74 74 75 76 76 77 77 77 77 77 77 77 77 77 83 85 85 88 88 89 91 92 93 93 93 93 93 93 93 93 100 100 100 100 100 100 100]

能够发现有不少元素是相同的，这就是这段代码的第一个错误：使用闭包函数的时候，代码中这种传递参数i的方法并不是深copy，而是传递变量指针。解释一下产生这种状况的缘由：在并发执行时因为某一个协程修改了i的值，致使多个协程append的时候变量**i**的值发生变化，从而致使有多个重复的元素。
将代码修改成：

func main() {
    var a []int
    for i := 0; i < 100; i++ {
        go func(i int) {
            a = append(a, i)
        }(i)
    }
    time.Sleep(2 * time.Second)
    fmt.Println(a)
}

执行结果为：

[5 4 8 7 2 12 15 13 14 24 22 23 25 18 21 17 20 28 29 31 30 32 33 34 35 36 37 38 39 41 40 42 44 50 45 48 49 55 51 52 53 54 46 47 57 56 58 59 60 65 61 62 63 64 68 66 67 70 69 72 74 71 73 75 76 80 77 78 79 86 81 82 83 85 89 87 88 84 90 91 92 95 93 94 97 96 98 99]

能够看到没有重复元素了，可是却缺乏一些元素，这就引出了第二个问题。

多个协程的竞争问题

如上述代码，执行屡次都会发现每次执行的结果都会少一些元素，其实真正的缘由是没有对于竞争的协程加互斥锁，致使资源的丢失。
解释这个问题要对go的数组、切片、以及append机制有一些了解，参考：

Arrays, slices (and strings): The mechanics of 'append'

如今知道咱们声明的切片不一样于数组，在每次append的时候咱们会伴随着内存copy以达到自动扩容目的，在A协程读出a的内存数据时，B协程完成了写入操做，此时A继续append并赋值就会致使，协程B的更新结果丢失。
假如咱们将切片换成数组就不存在这个问题：

func main() {
    var a [100]int
    for i := 0; i < 100; i++ {
        go func(i int) {
            // a = append(a, i)
            a[i] = i
        }(i)
    }
    time.Sleep(2 * time.Second)
    fmt.Println(a)
}

结果

[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]

或者互斥锁，

func main() {
    var a []int
    var mu sync.Mutex
    for i := 0; i < 100; i++ {
        go func(i int) {
            mu.Lock()
            a = append(a, i)
            mu.Unlock()
        }(i)
    }
    time.Sleep(2 * time.Second)
    fmt.Println(a)
}

结果

[1 0 2 9 7 8 10 4 5 3 11 6 12 14 13 16 15 23 20 21 22 19 25 24 17 26 18 27 28 29 32 30 31 34 35 36 40 33 37 39 38 42 43 41 44 51 45 49 50 55 52 53 48 54 46 47 57 56 58 59 60 64 61 62 63 68 72 70 71 74 69 75 73 65 66 67 76 79 77 78 85 80 81 82 83 84 86 88 87 90 89 91 92 93 96 94 95 97 98 99]

结论

• 闭包使用注意变量传递是指针仍是值，及注意闭包变量的两种传递方式。
• 注意线程安全。

结语

但愿你们一块儿学习，一块儿交流，一块儿进步！

联系我 qq：820932773 gmail: jdqaffairs@gmail.com