一些常見的併發程式設計錯誤 | Linux 中國

你認為程式的預期輸出是什麼？123 還是 789？事實上它的輸出與編譯器有關。對於標準的 Go 編譯器 1.10 來說，這個程式很有可能輸出是 123。但是在理論上，它可能輸出的是 789，或者其它的隨機數。

現在，我們來改變 c  為 c ，然後再次執行這個程式。你將會發現輸出變成了 789 （使用標準的 Go 編譯器 1.10）。這再次說明它的輸出是與編譯器相關的。

是的，在上面的程式中存在資料爭用。運算式 *p 可能會被先計算、後計算、或者在處理賦值陳述句 num = 789 時計算。time.Sleep 呼叫並不能保證 *p 發生在賦值陳述句處理之前進行。

對於這個特定的示例，我們將在新的協程建立之前，將值儲存到一個臨時值中，然後在新的協程中使用臨時值去消除資料爭用。

...
    tmp := *p + x
    go func() {
        c  tmp
    }()
...

使協程掛起

掛起協程是指讓協程一直處於阻塞狀態。導致協程被掛起的原因很多。比如，

除了有時我們為了避免程式退出，特意讓一個程式中的 main 協程保持掛起之外，大多數其它的協程掛起都是意外情況。Go 執行時很難判斷一個協程到底是處於掛起狀態還是臨時阻塞。因此，Go 執行時並不會去釋放一個掛起的協程所佔用的資源。

在 誰先響應誰獲勝[6] 的通道使用案例中，如果使用的 future 通道容量不夠大，當嘗試向 Future 通道傳送結果時，一些響應較慢的通道將被掛起。比如，如果呼叫下麵的函式，將有 4 個協程處於永遠阻塞狀態。

func request() int {
    c := make(chan int)
    for i := 0; i < 5; i++ {
        i := i
        go func() {
            c  i // 4 goroutines will hang here.
        }()
    }
    return c
}

為避免這 4 個協程一直處於掛起狀態， c 通道的容量必須至少是  4。

在 實現誰先響應誰獲勝的第二種方法[7] 的通道使用案例中，如果將 future 通道用做非緩衝通道，那麼有可能這個資訊將永遠也不會有響應而掛起。例如，如果在一個協程中呼叫下麵的函式，協程可能會掛起。原因是，如果接收操作   準備就緒之前，五個傳送操作全部嘗試傳送，那麼所有的嘗試傳送的操作將全部失敗，因此那個呼叫者協程將永遠也不會接收到值。

func request() int {
    c := make(chan int)
    for i := 0; i < 5; i++ {
        i := i
        go func() {
            select {
            case c  i:
            default:
            }
        }()
    }
    return c
}

將通道 c 變成緩衝通道將保證五個傳送操作中的至少一個操作會傳送成功，這樣，上面函式中的那個呼叫者協程將不會被掛起。

在 sync 標準包中複製型別值

在實踐中，sync 標準包中的型別值不會被複製。我們應該只複製這個值的指標。

下麵是一個錯誤的併發程式設計示例。在這個示例中，當呼叫 Counter.Value 方法時，將複製一個 Counter 接收值。作為接收值的一個欄位，Counter 接收值的各個 Mutex 欄位也會被複製。複製不是同步發生的，因此，複製的 Mutex 值可能會出錯。即便是沒有錯誤，複製的 Counter 接收值的訪問保護也是沒有意義的。

import "sync"
type Counter struct {
    sync.Mutex
    n int64
}
// This method is okay.
func (c *Counter) Increase(d int64) (r int64) {
    c.Lock()
    c.n += d
    r = c.n
    c.Unlock()
    return
}
// The method is bad. When it is called, a Counter
// receiver value will be copied.
func (c Counter) Value() (r int64) {
    c.Lock()
    r = c.n
    c.Unlock()
    return
}

package main
import (
    "fmt"
    "sync"
    "sync/atomic"
)
func main() {
    var wg sync.WaitGroup
    var x int32 = 0
    for i := 0; i < 100; i++ {
        go func() {
            wg.Add(1)
            atomic.AddInt32(&x, 1)
            wg.Done()
        }()
    }
    fmt.Println("To wait ...")
    wg.Wait()
    fmt.Println(atomic.LoadInt32(&x))
}

...
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            atomic.AddInt32(&x, 1)
            wg.Done()
        }()
    }
...

doSomethingWithFutureArguments(fa(), fb())

ca, cb := fa(), fb()
doSomethingWithFutureArguments(c1, c2)

import (
    "fmt"
    "time"
)
// The function will return if a message arrival interval
// is larger than one minute.
func longRunning(messages chan string) {
    for {
        select {
        case time.After(time.Minute):
            return
        case msg := messages:
            fmt.Println(msg)
        }
    }
}

func longRunning(messages chan string) {
    timer := time.NewTimer(time.Minute)
    defer timer.Stop()
    for {
        select {
        case timer.C:
            return
        case msg := messages:
            fmt.Println(msg)
            if !timer.Stop() {
                timer.C
            }
        }
        // The above "if" block can also be put here.
        timer.Reset(time.Minute)
    }
}

package main
import (
    "fmt"
    "time"
)
func main() {
    start := time.Now()
    timer := time.NewTimer(time.Second/2)
    select {
    case timer.C:
    default:
        time.Sleep(time.Second) // go here
    }
    timer.Reset(time.Second * 10)
    timer.C
    fmt.Println(time.Since(start)) // 1.000188181s
}