互斥鎖

對于任一共享資源，同一時間保證只有一個操作者，這種方法稱為 互斥機制，

關鍵字 Mutex 表示互斥鎖型別，它的 Lock 方法用于獲取鎖，Unlock 方法用于釋放鎖，在 Lock 和 Unlock 之間的代碼，可以讀取和修改共享資源，這部磁區域稱為 臨界區，

錯誤的并發操作

先來看一個錯誤的示例，

在 Map 小節中講到， Map 不是并發安全的， 也就是說，如果在多個執行緒中，同時對一個 Map 進行讀寫，會報錯，現在來驗證一下，通過啟動 100 個 goroutine 來模擬并發呼叫，每個 goroutine 都對 Map 的 key 進行設定，

package main

import "sync"

func main() {
    m := make(map[int]bool)

    var wg sync.WaitGroup

    for j := 0; j < 100; j++ {
        wg.Add(1)

        go func(key int) {
            defer func() {
                wg.Done()
            }()

            m[key] = true // 對 Map 進行并發寫入
        }(j)
    }

    wg.Wait()
}

// $ go run main.go
// 輸出如下，報錯資訊
/**
  fatal error: concurrent map writes
  fatal error: concurrent map writes

  goroutine 104 [running]:
  main.main.func1(0x0?)
          /home/codes/Go-examples-for-beginners/main.go:18 +0x66
  created by main.main
          /home/codes/Go-examples-for-beginners/main.go:13 +0x45

  goroutine 1 [semacquire]:
  sync.runtime_Semacquire(0xc0000112c0?)
          /usr/local/go/src/runtime/sema.go:62 +0x25
  sync.(*WaitGroup).Wait(0x60?)
          /usr/local/go/src/sync/waitgroup.go:139 +0x52
  main.main()
          /home/codes/Go-examples-for-beginners/main.go:22 +0x105

  ...
  ...
  ...
*/

通過輸出資訊 fatal error: concurrent map writes 可以看到，并發寫入 Map 確實會報錯，

正確的并發操作

Map 并發寫入如何正確地實作呢？

一種簡單的方案是在并發臨界區域 (也就是設定 Map key 的地方) 進行加互斥鎖操作， 互斥鎖保證了同一時刻只有一個 goroutine 獲得鎖，其他 goroutine 全部處于等待狀態，這樣就把并發寫入變成了串行寫入，從而消除了報錯問題，

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    m := make(map[int]bool)

    var wg sync.WaitGroup

    for j := 0; j < 100; j++ {
        wg.Add(1)

        go func(key int) {
            defer func() {
                wg.Done()
            }()

            mu.Lock()     // 寫入前加鎖
            m[key] = true // 對 Map 進行并發寫入
            mu.Unlock()   // 寫入完成解鎖
        }(j)
    }

    wg.Wait()

    fmt.Printf("Map size = %d\n", len(m))
}

// $ go run main.go
// 輸出如下
/**
  Map size = 100
*/

超時控制

利用 channel (通道) 和 time.After() 方法實作超時控制，

例子

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan bool)

    go func() {
        defer func() {
            ch <- true
        }()

        time.Sleep(2 * time.Second) // 模擬超時操作
    }()

    select {
    case <-ch:
        fmt.Println("ok")
    case <-time.After(time.Second):
        fmt.Println("timeout!")
    }
}

// $ go run main.go
// 輸出如下
/**
  timeout!
*/

定時器

呼叫 time.NewTicker 方法即可，

例子

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()

    done := make(chan bool)
    go func() {
        time.Sleep(5 * time.Second) // 模擬耗時操作
        done <- true
    }()

    for {
        select {
        case <-done:
            fmt.Println("Done!")
            return
        case <-ticker.C:
            fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
        }
    }
}

// $ go run main.go
// 輸出如下，你的輸出可能和這里的不一樣
/**
  2021-01-03 15:40:21
  2021-01-03 15:40:22
  2021-01-03 15:40:23
  2021-01-03 15:40:24
  2021-01-03 15:40:25
  Done!
*/