竟險

竟險（競爭條件、Race Condition）是指多個協程（goroutine）同時訪問共享資料，其結果取決於指令執行順序的情況。

考慮如下售票程式。該程式模擬兩個售票視窗，一個執行購票，一個執行退票。

package main

import (
    "fmt"
    "time"
)

var tickCount = 200 // 總票數

// 購票
func buy() {
    tickCount = tickCount - 1 // A
}

// 退票
func refund() {
    tickCount = tickCount + 1 // B
}

func main() {

    go
 
 buy()    // 購票協程
    go refund() // 退票協程

    time.Sleep(time.Second * 1) // 為了簡單，這裡睡眠1秒，等待上面兩個協程結束

    fmt.Println("tick count:", tickCount) // 輸出結果是什麼？
}

考慮到一共200張票，買了一張，賣了一張，應該還是剩餘200張票。事實卻不總是這樣，多次執行程式發現有如下輸出：

tick count: 201

和如下輸出：

tick count: 199

多的一張和少的一張到哪裡去了？無論是先執行買票（語句A）還是賣票（語句B），結果都應該是200才對啊！

NO!!!

在計算機看來語句A和語句B並不是一條不可分割的語句，而是兩條語句：

A1: … = tickCount - 1
A2: tickCount = …
B1: … = tickCount + 1
B2: tickCount = …

它們的實際執行順序有如下四種可能：

• A1->A2->B1->B2 結果為200
• B1->B2->A1->A2 結果為200
• B1->A1->A2->B2 結果為201
• A1->B1->B2->A2 結果為199

可見第三種和第四種執行順序產生了意想不到的結果。原因在於兩個協程同時訪問並修改了共享變數（tickCount），而語句之間的順序無法保證，導致意外的情況發生，這便是竟險。

竟險顯然不是我們想要的結果。那麼如何規避竟險呢?有三種方式：1. 禁止修改共享變數。2. 限制在同一個協程中訪問共享變數。3. 利用互斥。下面分別來看看這三種方式。

禁止修改共享變數

可以通過禁止修改共享變數來達到規避竟險的目的。

考慮如下程式：

package main

var config = map[string]string{}

func loadConfig(key string) string { /*...*/ }

// 惰性載入
func getConfig(key string) string {
    value, ok := config[key]
    if !ok {
        value = loadConfig(key)
        config[key] = value
    }
    return value
}

func main() {

    go func() {
        user := getConfig("userName") // A 修改共享變數的值，發生竟險
        // ...
    }()

    go func() {
        address := getConfig("address") // B 修改共享變數的值，發生竟險
        // ...
    }()

    // ...
}

注意該例中getConfig()為惰性載入，也就是在需要載入時再載入，這樣便在語句A和語句B中發生了竟險，兩條語句同時修改了共享變數config。如果修改為提前載入所有配置，則可規避竟險：

package main

// 提前載入所有配置
var config = map[string]string{
    "userName": loadConfig("userName"),
    "address":  loadConfig("address"),
}

func loadConfig(key string) string { /*...*/ }

func getConfig(key string) string {
    return config[key]
}

func main() {

    go func() {
        user := getConfig("userName")  // 訪問共享變數，但不修改其值，不發生竟險
        // ...
    }()

    go func() {
        address := getConfig("address")  // 訪問共享變數，但不修改其值，不發生竟險
        // ...
    }()

    // ...
}

這種方式僅僅可以用於協程不需要修改共享變數的情況。這顯然滿足不了我們的所有需求。在很多情況下協程必須修改共享變數。

限制在同一個協程中訪問共享變數

將共享變數的訪問限制在一個協程中，就避免了竟險。 不過這種方式略微有些複雜，必須要建立一個監聽執行緒，來專門處理共享變數的修改。

package main

import (
    "fmt"
    "sync"
)

var tickCount = 200            // 總票數
var ch = make(chan int, 10)    // 用來控制tickCount的同步，10表示模擬10個售/退票視窗
var n sync.WaitGroup           // 用來等待購票和售票動作完成
var done = make(chan struct{}) // 用來等待監聽協程退出

// 購票
func buy() {
    ch <- -1
}

// 退票
func refund() {
    ch <- 1
}

func main() {

    // 監聽協程
    go func() {
        for amount := range ch {
            tickCount += amount
            n.Done() // 每次呼叫Done()，n的計數減1
        }
        done <- struct{}{}  // 監聽執行緒結束，傳送訊息
    }()

    n.Add(2)    // 因為要執行兩個動作，所以使n的計數加2
    go buy()    // 購票協程
    go refund() // 退票協程

    n.Wait() // 等待購票和退票動作完成
             // Wait()會一直等待，直到n的計數為0

    close(ch) // 關閉管道

    <-done // 等待監聽執行緒結束

    fmt.Println("tick count:", tickCount)
}

這種方式類似於在Windows的執行緒中處理訊息迴圈，用PostThreadMessage來發送訊息。可以對比一下：

#include <Windows.h>
#include <iostream>

#define WM_AMOUNT (WM_USER + 1)
#define WM_DONE (WM_USER + 2)

int tickCount = 200;  // 總票數200
DWORD dwThreadId = 0;  // 監聽執行緒ID
HANDLE hEventState = NULL;  // 用於同步監聽執行緒的開始和結束

// 監聽執行緒
DWORD WINAPI Monitor(LPVOID lpParameter) {

    // 確保建立訊息迴圈
    MSG msg = {};
    PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);

    // 通知主執行緒訊息迴圈建立完成
    SetEvent(hEventState);

    // 處理訊息
    BOOL bRet;
    bool done = false;
    while (!done && (bRet = GetMessage(&msg, NULL, 0, 0)) != 0) {
        if (bRet == -1) {
            break;
        } else {
            switch (msg.message)
            {
            case WM_AMOUNT:
                tickCount += (int)msg.wParam;
                break;
            case WM_DONE:
                done = true;
                break;
            default:
                break;
            }
        }
    }

    SetEvent(hEventState);

    return 0;
}

// 購票
void buy() {
    PostThreadMessage(dwThreadId, WM_AMOUNT, (WPARAM)-1, NULL);
}

// 退票
void refund() {
    PostThreadMessage(dwThreadId, WM_AMOUNT, (WPARAM)1, NULL);
}

int main() {

    hEventState = CreateEvent(NULL, FALSE, FALSE, NULL);  // 建立同步監聽執行緒的事件

    // 開啟監聽執行緒
    HANDLE hThread = CreateThread(NULL, 0, Monitor, NULL, 0, &dwThreadId);
    CloseHandle(hThread);

    WaitForSingleObject(hEventState, INFINITE); // 確保監聽執行緒已開啟

    buy();  // 購票
    refund();  // 退票

    PostThreadMessage(dwThreadId, WM_DONE, NULL, NULL);  // 退出監聽執行緒

    WaitForSingleObject(hEventState, INFINITE);  // 等待監聽執行緒退出

    CloseHandle(hEventState); // 關閉同步監聽執行緒的事件

    std::cout << "tick count: " << tickCount << std::endl;
}

可見C++的版本複雜了一些，不過也差不了多少。

利用互斥

第三種方式是使用sync包中提供的互斥鎖sync.Mutex。sync.Mutex是一個結構體，提供了Lock和Unlock兩個方法，Lock用來鎖定，Unlock用來解鎖。 利用互斥鎖，上面的程式變得更簡單了：

package main

import (
    "fmt"
    "sync"
)

var (
    tickCount = 200 // 總票數
    mu        sync.Mutex  // 互斥鎖
    n         sync.WaitGroup
)

// 購票
func buy() {
    defer n.Done()  // 計數減1
    mu.Lock()
    defer mu.Unlock()  // 用defer保證函式返回時解鎖
    tickCount += 1
}

// 退票
func refund() {
    defer n.Done()  // 計數減1
    mu.Lock()
    defer mu.Unlock()  // 用defer保證函式返回時解鎖
    tickCount -= 1
}

func main() {

    n.Add(2)    // 有兩個動作，所以計數加2
    go buy()    // 購票協程
    go refund() // 退票協程

    n.Wait() // 等待購票和退票動作完成
             // Wait一直阻塞，直到n的計數為0返回

    fmt.Println("tick count:", tickCount)
}

總結

• 多個協程同時訪問共享資料時會造成竟險。
• 可以有三種方式規避竟險：禁止修改共享變數、限制在同一個協程中訪問共享變數、 利用互斥物件。