Concurrency

• 使用concurrency來撰寫程式，可以進行平行處理(parallel computing)來提升效能。Go關於concurrency的內容包含goroutines, channels, range&close, select等

Goroutine

• Goroutine類似thread，是做為並行執行的程式碼區塊。
• : 使用時僅須在函數前加上關鍵字go即可。
package main import ( "fmt" "time" ) func say(s string) { for i := 0; i < 5; i++ { time.Sleep(2000 * time.Millisecond) fmt.Println(s, " ", i) } } func main() { go say("world") time.Sleep(time.Second*5) go say("hello") time.Sleep(time.Second*8) }
• 使用time.Sleep()函數讓程式休息但不關閉，否則main thread關閉程式便結束了，看不到其他結果。
• 使用time.Sleep()函數前須記得import time這個package。
• 每一個routing(thread)爭搶程式執行權，得到者執行程式，所以無法有固定順序執行。

Channel

• 前述的goroutine相互獨立，而Go使用channel在不同並行程式間傳遞資料。
• 需先宣告channel後方能使用，宣告使用make()函數。
package main import ( "fmt" ) func trans(s string, c chan string){ c <- s } func main() { message := make(chan string) go trans("Hello World!", message) msg := <-message fmt.Println(msg) }
• 使用make(chan string)來建立一個傳遞string的channel。
• msg := <-message是將資訊由message傳遞到msg，<-箭頭表示傳遞方向。
• : 再試一個例子。
package main import ( "fmt" "math/rand" ) func sum(a [] int, c chan int){ s:=0 for _, v:= range a{ s = s + v } c <- s } func main() { rand.Seed(10) var a[10]int for i:=range a{ a[i] = rand.Intn(100) } c:=make(chan int) go sum(a[:len(a)/2], c) go sum(a[len(a)/2:], c) x:= <-c y:= <-c fmt.Println(x, y, x+y) }
• 第一個go計算前半段的array元素和，第二個計算後半段。
• : Buffered Channel是可以在宣告channel時設定其buffer，有了buffer後可不需等待其他的goroutine，直接傳送資料。
package main import "fmt" func main() { c:=make(chan string, 2) c <- "Hello" c <- "World" fmt.Println(<-c) fmt.Println(<-c) }
• 設置兩個buffer，傳送(<-)兩次(也就是說傳送3次會出現錯誤，但可以增加goroutine的方式傳送，e.g.)。
package main import "fmt" func main() { c:=make(chan string, 2) c <- "Hello" c <- "World" go func(){c<-"Tom"}() fmt.Println(<-c) fmt.Println(<-c) fmt.Println(<-c) }
• : 若不再使用channel時，可使用close()將其關閉。
package main import "fmt" func main() { c:=make(chan string, 5) c <- "Hello" c <- "World" close(c) fmt.Println(<-c) fmt.Println(<-c) fmt.Println(<-c) }
• 原本設置5個buffer，使用兩個後關閉，再使用傳回空。
• channel跟file不同，除非要強調不再有資料傳入，否則不需特別關閉(close)，以fibonacci sequence為例。
package main import "fmt" func fibonacci(n int, c chan int){ a,b := 0,1 for i:=0; i<n; i++{ c <- a a, b = b, a+b } close(c) } func main() { c:=make(chan int, 10) go fibonacci(cap(c), c) for i:=range c{ fmt.Println(i) } }
• cap(c)表示c的capacity(也就是10)。
• : 之前提到過的select適用於選擇不同的channel，再試一個例子。
package main import "fmt" import "time" func main() { c1:=make(chan string) c2:=make(chan string) f1 := func(){ time.Sleep(time.Second * 1) c1 <- "Function 1" } f2 := func(){ time.Sleep(time.Second * 1) c2 <- "Function 2" } go f1() go f2() for i:=0; i<2; i++{ select{ case m1:= <-c1: fmt.Println("Received from", m1) case m2:= <-c2: fmt.Println("Received from", m2) } } }
• 出現順序不固定，看哪一個goroutine先搶到執行。
• 試試看給每個channel一個buffer，去除time.Sleep()。
• 使用select方式建立另一個求取fibonacci sequence的程式。
package main import "fmt" func fibonacci(c, quit chan int){ a,b := 0,1 for{ select{ case c <- a: a,b=b, a+b case <-quit: fmt.Println("quit") return } } } func main() { c := make(chan int) quit := make(chan int) go func(){ for i:=0; i<10; i++{ fmt.Println(<-c) } quit <- 0 }() fibonacci(c, quit) }
• quit <- 0可以傳送任意整數來停止程式，主要是要偵測到這個channel被使用。
• 有default condition的情況，e.g.
package main import "fmt" import "time" func main() { tick := time.Tick(time.Millisecond*1000) after := time.After(time.Millisecond*5000) second:=1 for{ select{ case <- tick: fmt.Println(second) second++ case <- after: fmt.Println(second, "Time is up.") return default: fmt.Print(".") time.Sleep(100*time.Millisecond) } } }