1. Goroutine

1.1 Go 在語言層面對併發程式設計提供支援，一種類似協程，稱作 goroutine 的機制

• 怎麼實現go程呢，只需在函式呼叫語句前新增 go 關鍵字，就可建立併發執行單元。開發⼈人員無需瞭解任何執行細節，排程器會自動將其安排到合適的系統執行緒上執行。goroutine 是一種⾮非常輕量級的實現，可在單個程序裡執行成千上萬的併發任務。
• 事實上，入口函式 main 就以 goroutine 執行。另有與之配套的 channel 型別，用以實現 “以通訊來共享記憶體” 的 CSP 模式。

go func() {
    println
 
("Hello, World!")
}()

• 排程器不能保證多個 goroutine 執行次序，且程序退出時不會等待它們結束
• 預設情況下，程序啟動後僅允許一個系統執行緒服務於 goroutine。可使用環境變數或標準庫函式 runtime.GOMAXPROCS 修改，讓排程器用多個執行緒實現多核並行，而不僅僅是併發

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {
	wg := new(sync.WaitGroup)
	wg.Add(1)

	go func() {
		defer wg.
 
Done()
		defer fmt.Println("A.defer")

		func() {
			defer fmt.Println("B.defer")
			runtime.Goexit() // 終⽌止當前 goroutine
			fmt.Println("B") // 不會執⾏行
		}()

		fmt.Println("A") // 不會執⾏行
	}()

	wg.Wait()
}

1.2 和協程 yield 作用類似，Gosched 讓出底層執行緒，將當前 goroutine 暫停，放回佇列等待下次被排程執行

package main

import (
	"fmt"
	"runtime"
 

	"sync"
)

func main() {
	wg := new(sync.WaitGroup)
	wg.Add(2)

	go func() {
		defer wg.Done()

		for i := 0; i < 6; i++ {
			fmt.Println(i)

			if i == 3 {
				runtime.Gosched()
			}
		}
	}()

	go func() {
		defer wg.Done()
		fmt.Println("Hello, World!")
	}()

	wg.Wait()
}

1.3 Channel

• 引用型別 channel 是 CSP 模式的具體實現，用於多個 goroutine 通訊。其內部實現了同步，確保併發安全
• 預設為同步模式，需要傳送和接收配對。否則會被阻塞，直到另一方準備好後被喚醒

package main

import "fmt"

func main() {
	data := make(chan int)  // 資料交換佇列
	exit := make(chan bool) // 退出通知

	go func() {
		for d := range data { // 從佇列迭代接收資料，直到 close 。
			fmt.Println(d)
		}
		fmt.Println("recv over.")
		exit <- true // 發出退出通知。
	}()

	data <- 1 // 傳送資料。
	data <- 2
	data <- 3
	close(data) // 關閉佇列。

	fmt.Println("send over.")
	<-exit // 等待退出通知。
}

1.4 非同步方式通過判斷緩衝區來決定是否阻塞。如果緩衝區已滿，傳送被阻塞；緩衝區為空，接收被阻塞。

• 通常情況下，非同步 channel 可減少排隊阻塞，具備更高的效率。但應該考慮使用指標規避大物件拷貝，將多個元素打包，減小緩衝區大小等。

func main() {
    data := make(chan int, 3) // 緩衝區可以儲存 3 個元素
    exit := make(chan bool)

      data <- 1 // 在緩衝區未滿前，不會阻塞。
      data <- 2
      data <- 3

      go func() {
          for d := range data { // 在緩衝區未空前，不會阻塞。
              fmt.Println(d)
        }

        exit <- true
    }()

    data <- 4 // 如果緩衝區已滿，阻塞。
    data <- 5
    close(data)

    <-exit
}

• 緩衝區是內部屬性，並非型別構成要素。

var a, b chan int = make(chan int), make(chan int, 3)

• 除用 range 外，還可用 ok-idiom 模式判斷 channel 是否關閉。

for {
    if d, ok := <-data; ok {
        fmt.Println(d)
    } else {
        break
    }
}

• 向 closed channel 傳送資料引發 panic 錯誤，接收立即返回零值。而 nil channel，無論收發都會被阻塞。

1.5 內建函式 len 返回未被讀取的緩衝元素數量，cap 返回緩衝區大小。

d1 := make(chan int)
d2 := make(chan int, 3)

d2 <- 1

fmt.Println(len(d1), cap(d1)) // 0 0
fmt.Println(len(d2), cap(d2)) // 1 3

1.6 單向

• 可以將 channel 隱式轉換為單向佇列，只收或只發。

c := make(chan int, 3)
var send chan<- int = c // send-only
var recv <-chan int = c // receive-only
send <- 1
// <-send // Error: receive from send-only type chan<- int
<-recv
// recv <- 2 // Error: send to receive-only type <-chan int

• 不能將單向 channel 轉換為普通 channel

d := (chan int)(send) // Error: cannot convert type chan<- int to type chan int
d := (chan int)(recv) // Error: cannot convert type <-chan int to type chan int

1.7 選擇

• 如果需要同時處理多個 channel，可使用 select 語句。它隨機選擇一個可用 channel 做收發操作，或執行 default case。

package main

import (
	"fmt"
	"os"
)

func main() {
	a, b := make(chan int, 3), make(chan int)

	go func() {
		v, ok, s := 0, false, ""

		for {
			select { // 隨機選擇可用 channel，接收資料。
			case v, ok = <-a:
				s = "a"
			case v, ok = <-b:
				s = "b"
			}

			if ok {
				fmt.Println(s, v)
			} else {
				os.Exit(0)
			}
		}
	}()

	for i := 0; i < 5; i++ {
		select { // 隨機選擇可用 channel，傳送資料。
		case a <- i:
		case b <- i:
		}
	}

	close(a)
	select {} // 沒有可用 channel，阻塞 main goroutine。
}

• 在迴圈中使用 select default case 需要小心，避免形成洪水。