Channel
1. 概述
「網絡，併發」是Go語言的兩大feature。Go語言號稱「互聯網的C語言」，與使用傳統的C語言相比，寫一個Server所使用的代碼更少，也更簡單。寫一個Server除了網絡，另外就是併發，相對python等其它語言，Go對併發支持使得它有更好的性能。html
Goroutine和channel是Go在「併發」方面兩個核心feature。python
Channel是goroutine之間進行通訊的一種方式，它與Unix中的管道相似。golang
Channel聲明：編程
ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .網絡
例如：併發
var ch chan int函數
var ch1 chan<- int //ch1只能寫post
var ch2 <-chan int //ch2只能讀性能
channel是類型相關的，也就是一個channel只能傳遞一種類型。例如，上面的ch只能傳遞int。ui
在go語言中，有4種引用類型：slice，map，channel，interface。
Slice，map，channel通常都經過make進行初始化：
ci := make(chan int) // unbuffered channel of integers
cj := make(chan int, 0) // unbuffered channel of integers
cs := make(chan *os.File, 100) // buffered channel of pointers to Files
建立channel時能夠提供一個可選的整型參數，用於設置該channel的緩衝區大小。該值缺省爲0，用來構建默認的「無緩衝channel」，也稱爲「同步channel」。
Channel做爲goroutine間的一種通訊機制，與操做系統的其它通訊機制相似，通常有兩個目的：同步，或者傳遞消息。
2. 同步
c := make(chan int) // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
list.Sort()
c <- 1 // Send a signal; value does not matter.
}()
doSomethingForAWhile()
<-c // Wait for sort to finish; discard sent value.
上面的示例中，在子goroutine中進行排序操做，主goroutine能夠作一些別的事情，而後等待子goroutine完成排序。
接收方會一直阻塞直到有數據到來。若是channel是無緩衝的，發送方會一直阻塞直到接收方將數據取出。若是channel帶有緩衝區，發送方會一直阻塞直到數據被拷貝到緩衝區；若是緩衝區已滿，則發送方只能在接收方取走數據後才能從阻塞狀態恢復。
3. 消息傳遞
咱們來模擬一下經典的生產者－消費者模型。
func Producer (queue chan<- int){
for i:= 0; i < 10; i++ {
queue <- i
}
}
func Consumer( queue <-chan int){
for i :=0; i < 10; i++{
v := <- queue
fmt.Println("receive:", v)
}
}
func main(){
queue := make(chan int, 1)
go Producer(queue)
go Consumer(queue)
time.Sleep(1e9) //讓Producer與Consumer完成
}
上面的示例在Producer中生成數據，在Consumer中處理數據。
4. Server編程模型
在server編程，一種經常使用的模型：主線程接收請求，而後將請求分發給工做線程，工做線程完成請求處理。用go來實現，以下：
func handle(r *Request) {
process(r) // May take a long time.
}
func Serve(queue chan *Request) {
for {
req := <-queue
go handle(req) // Don't wait for handle to finish.
}
}
通常來講，server的處理能力不是無限的，因此，有必要限制線程（或者goroutine）的數量。在C/C++編程中，咱們通常經過信號量來實現，在go中，咱們能夠經過channel達到一樣的效果：
var sem = make(chan int, MaxOutstanding)
func handle(r *Request) {
sem <- 1 // Wait for active queue to drain.
process(r) // May take a long time.
<-sem // Done; enable next request to run.
}
func Serve(queue chan *Request) {
for {
req := <-queue
go handle(req) // Don't wait for handle to finish.
}
}
咱們經過引入sem channel，限制了同時最多隻有MaxOutstanding個goroutine運行。可是，上面的作法，只是限制了運行的goroutine的數量，並無限制goroutine的生成數量。若是請求到來的速度過快，會致使產生大量的goroutine，這會致使系統資源消耗徹底。
爲此，咱們有必要限制goroutine的建立數量：
func Serve(queue chan *Request) {
for req := range queue {
sem <- 1
go func() {
process(req) // Buggy; see explanation below.
<-sem
}()
}
}
上面的代碼看似簡單清晰，但在go中，卻有一個問題。Go語言中的循環變量每次迭代中是重用的，更直接的說就是req在全部的子goroutine中是共享的，從變量的做用域角度來講，變量req對於全部的goroutine，是全局的。
這個問題屬於語言實現的範疇，在C語言中，你不該該將一個局部變量傳遞給另一個線程去處理。有不少解決方法，這裏有一個討論。從我的角度來講，我更傾向下面這種方式：
func Serve(queue chan *Request) {
for req := range queue {
sem <- 1
go func(r *Request) {
process(r)
<-sem
}(req)
}
}
至少，這樣的代碼不會讓一個go的初學者不會迷糊，另外，從變量的做用域角度，也更符合常理一些。
在實際的C/C++編程中，咱們傾向於工做線程在一開始就建立好，並且線程的數量也是固定的。在go中，咱們也能夠這樣作：
func handle(queue chan *Request) {
for r := range queue {
process(r)
}
}
func Serve(clientRequests chan *Request, quit chan bool) {
// Start handlers
for i := 0; i < MaxOutstanding; i++ {
go handle(clientRequests)
}
<-quit // Wait to be told to exit.
}
開始就啓動固定數量的handle goroutine，每一個goroutine都直接從channel中讀取請求。這種寫法比較簡單，可是不知道有沒有「驚羣」問題？有待後續分析goroutine的實現。
5. 傳遞channel的channel
channel做爲go語言的一種原生類型，天然能夠經過channel進行傳遞。經過channel傳遞channel，能夠很是簡單優美的解決一些實際中的問題。
在上一節中，咱們主goroutine經過channel將請求傳遞給工做goroutine。一樣，咱們也能夠經過channel將處理結果返回給主goroutine。
主goroutine：
type Request struct {
args []int
resultChan chan int
}
request := &Request{[]int{3, 4, 5}, make(chan int)}
// Send request
clientRequests <- request
// Wait for response.
fmt.Printf("answer: %d\n", <-request.resultChan)
主goroutine將請求發給request channel，而後等待result channel。子goroutine完成處理後，將結果寫到result channel。
func handle(queue chan *Request) {
for req := range queue {
result := do_something()
req.resultChan <- result
}
}
6. 多個channel
在實際編程中，常常會遇到在一個goroutine中處理多個channel的狀況。咱們不可能阻塞在兩個channel，這時就該select場了。與C語言中的select能夠監控多個fd同樣，go語言中select能夠等待多個channel。
c1 := make(chan string)
c2 := make(chan string)
go func() {
time.Sleep(time.Second * 1)
c1 <- "one"
}()
go func() {
time.Sleep(time.Second * 2)
c2 <- "two"
}()
for i := 0; i < 2; i++ {
select {
case msg1 := <-c1:
fmt.Println("received", msg1)
case msg2 := <-c2:
fmt.Println("received", msg2)
}
}
在C中，咱們通常都會傳一個超時時間給select函數，go語言中的select沒有該參數，至關於超時時間爲0。
主要參考
https://golang.org/doc/effective_go.html