Go緩沖channel和非緩沖channel的區(qū)別說明

更新時(shí)間：2021年04月25日 11:18:05 作者：上官二狗

這篇文章主要介紹了Go緩沖channel和非緩沖channel的區(qū)別說明，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過來(lái)看看吧

在看本篇文章前我們需要了解阻塞的概念

在執(zhí)行過程中暫停，以等待某個(gè)條件的觸發(fā) ，我們就稱之為阻塞

在Go中我們make一個(gè)channel有兩種方式，分別是有緩沖的和沒緩沖的

緩沖channel 即 buffer channel 創(chuàng)建方式為 make(chan TYPE,SIZE)

如 make(chan int,3) 就是創(chuàng)建一個(gè)int類型，緩沖大小為3的 channel

非緩沖channel 即 unbuffer channel 創(chuàng)建方式為 make(chan TYPE)

如 make(chan int) 就是創(chuàng)建一個(gè)int類型的非緩沖channel

非緩沖channel 和緩沖channel 的區(qū)別

非緩沖 channel，channel 發(fā)送和接收動(dòng)作是同時(shí)發(fā)生的

例如 ch := make(chan int) ，如果沒 goroutine 讀取接收者<-ch ，那么發(fā)送者ch<- 就會(huì)一直阻塞

緩沖 channel 類似一個(gè)隊(duì)列，只有隊(duì)列滿了才可能發(fā)送阻塞

代碼演示

非緩沖 channel

package main
import (
 "fmt"
 "time"
)
func loop(ch chan int) {
 for {
  select {
  case i := <-ch:
   fmt.Println("this  value of unbuffer channel", i)
  }
 }
}
func main() {
 ch := make(chan int)
 ch <- 1
 go loop(ch)
 time.Sleep(1 * time.Millisecond)
}

這里會(huì)報(bào)錯(cuò) fatal error: all goroutines are asleep - deadlock! 就是因?yàn)?ch<-1 發(fā)送了，但是同時(shí)沒有接收者，所以就發(fā)生了阻塞

但如果我們把 ch <- 1 放到 go loop(ch) 下面，程序就會(huì)正常運(yùn)行

緩沖 channel

的阻塞只會(huì)發(fā)生在 channel 的緩沖使用完的情況下

package main
import (
 "fmt"
 "time"
)
func loop(ch chan int) {
 for {
  select {
  case i := <-ch:
   fmt.Println("this  value of unbuffer channel", i)
  }
 }
}
func main() {
 ch := make(chan int,3)
 ch <- 1
 ch <- 2
 ch <- 3
 ch <- 4
 go loop(ch)
 time.Sleep(1 * time.Millisecond)
}

這里也會(huì)報(bào) fatal error: all goroutines are asleep - deadlock! ，這是因?yàn)?channel 的大小為 3 ，而我們要往里面塞 4 個(gè)數(shù)據(jù)，所以就會(huì)阻塞住

解決的辦法有兩個(gè)

把 channel 開大一點(diǎn)，這是最簡(jiǎn)單的方法，也是最暴力的

把 channel 的信息發(fā)送者 ch <- 1 這些代碼移動(dòng)到 go loop(ch) 下面，讓 channel 實(shí)時(shí)消費(fèi)就不會(huì)導(dǎo)致阻塞了

補(bǔ)充：3種優(yōu)雅的Go channel用法

寫Go的人應(yīng)該都聽過Rob Pike的這句話

Do not communicate by sharing memory; instead, share memory by communicating.

相信很多朋友和我一樣，在實(shí)際應(yīng)用中總感覺不到好處，為了用channel而用。但以我的切身體會(huì)來(lái)說，這是寫代碼時(shí)碰到的場(chǎng)景不復(fù)雜、對(duì)channel不熟悉導(dǎo)致的，所以希望這篇文章能給大家?guī)?lái)點(diǎn)新思路，對(duì)Golang優(yōu)雅的channel有更深的認(rèn)識(shí) ：）

Fan In/Out

數(shù)據(jù)的輸出有時(shí)候需要做扇出／入（Fan In／Out），但是在函數(shù)中調(diào)用常常得修改接口，而且上下游對(duì)于數(shù)據(jù)的依賴程度非常高，所以一般使用通過channel進(jìn)行Fan In／Out，這樣就可以輕易實(shí)現(xiàn)類似于shell里的管道。

func fanIn(input1, input2 <-chan string) <-chan string {
   c := make(chan string)
   go func() {
       for {
           select {
           case s := <-input1:  c <- s
           case s := <-input2:  c <- s
           }
       }
   }()
   return c
}

同步Goroutine

兩個(gè)goroutine之間同步狀態(tài)，例如A goroutine需要讓B goroutine退出，一般做法如下：

func main() {
   g = make(chan int)
   quit = make(chan bool)
   go B()
   for i := 0; i < 3; i++ {
       g <- i
   }
   quit <- true // 沒辦法等待B的退出只能Sleep
   fmt.Println("Main quit")
}
func B() {
   for {
       select {
       case i := <-g:
           fmt.Println(i + 1)
       case <-quit:
           fmt.Println("B quit")
           return
       }
   }
}
/*
Output:
1
2
3
Main quit
*/

可是了main函數(shù)沒辦法等待B合適地退出，所以B quit 沒辦法打印，程序直接退出了。

然而，chan是Go里的第一對(duì)象，所以可以把chan傳入chan中，所以上面的代碼可以把quit 定義為chan chan bool，以此控制兩個(gè)goroutine的同步

func main() {
   g = make(chan int)
   quit = make(chan chan bool)
   go B()
   for i := 0; i < 5; i++ {
       g <- i
   }
   wait := make(chan bool)
   quit <- wait
   <-wait //這樣就可以等待B的退出了
   fmt.Println("Main Quit")
}
func B() {
   for {
       select {
       case i := <-g:
           fmt.Println(i + 1)
       case c := <-quit:
           c <- true
           fmt.Println("B Quit")
           return
       }
   }
}
/* Output
1
2
3
B Quit
Main Quit
*/

分布式遞歸調(diào)用

在現(xiàn)實(shí)生活中，如果你要找美國(guó)總統(tǒng)聊天，你會(huì)怎么做？

第一步打電話給在美國(guó)的朋友，然后他們也會(huì)發(fā)動(dòng)自己的關(guān)系網(wǎng)，再找可能認(rèn)識(shí)美國(guó)總統(tǒng)的人，以此類推，直到找到為止。

這在Kadmelia分布式系統(tǒng)中也是一樣的，如果需要獲取目標(biāo)ID信息，那么就不停地查詢，被查詢節(jié)點(diǎn)就算沒有相關(guān)信息，也會(huì)返回它覺得最近節(jié)點(diǎn)，直到找到ID或者等待超時(shí)。

好了，這個(gè)要用Go來(lái)實(shí)現(xiàn)怎么做呢？

func recursiveCall(ctx context.Context, id []byte, initialNodes []*node){
	seen := map[string]*node{} //已見過的節(jié)點(diǎn)記錄
	request := make(chan *node, 3) //設(shè)置請(qǐng)求節(jié)點(diǎn)channel
        // 輸入初始節(jié)點(diǎn)
	go func() {
		for _, n := range initialNodes {
			request <- n
		}
	}()
OUT:
	for {
               //循環(huán)直到找到數(shù)據(jù)
		if data != nil {
		    return
		}
                // 在新的請(qǐng)求，超時(shí)和上層取消請(qǐng)求中select
		select {
		case n := <-request:
			go func() {
                                // 發(fā)送新的請(qǐng)求
				response := s.sendQuery(ctx, n, MethodFindValue, id)
				select {
				case <-ctx.Done():
				case msg :=<-response:
                                    seen[responseToNode(response)] = n //更新已見過的節(jié)點(diǎn)信息
                                                // 加載新的節(jié)點(diǎn)
						for _, rn := range LoadNodeInfoFromByte(msg[PayLoadStart:]) {
							mu.Lock()
							_, ok := seen[rn.HexID()]
							mu.Unlock()
                                                        // 見過了，跳過這個(gè)節(jié)點(diǎn)
							if ok { 
 								continue
							}
							AddNode(rn)
                                                        // 將新的節(jié)點(diǎn)送入channel
							request <- rn
						}
					}
				}
			}()
		case <-time.After(500 * time.Millisecond):
			break OUT // break至外層，否則僅僅是跳至loop外
        	case <-ctx.Done():
			break OUT
		}
	}
	return
}

這時(shí)的buffered channel類似于一個(gè)局部queue，對(duì)需要的節(jié)點(diǎn)進(jìn)行處理，但這段代碼的精妙之處在于，這里的block操作是select的，隨時(shí)可以取消，而不是要等待或者對(duì)queue的長(zhǎng)度有認(rèn)識(shí)。

以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教。

您可能感興趣的文章: