閉包,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