Go中怎么使用channel

這篇文章將為大家詳細(xì)講解有關(guān)Go中怎么使用channel，小編覺得挺實(shí)用的，因此分享給大家做個(gè)參考，希望大家閱讀完這篇文章后可以有所收獲。

一、使用channel等待任務(wù)結(jié)束

使用案例還是在第一篇的第二節(jié)中寫的代碼，不過這里只需要一段即可。

package mainimport (
	"fmt"
	"time")func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c}func worker(id int, c chan int) {
	for n := range c {
		fmt.Printf("Worker %d receive %c\n", id, n)
	}}func channelDemo() {
	var channels [10]chan<- int
	for i := 0; i < 10; i++ {
		channels[i] = createWorker(i)
	}

	for i := 0; i < 10; i++ {
		channels[i] <- 'a' + i	}

	for i := 0; i < 10; i++ {
		channels[i] <- 'A' + i	}
	time.Sleep(time.Millisecond)}func main() {
	channelDemo()}

這里咔咔將原始源碼放在這里，如果你想跟著文章的節(jié)奏走，可以放到你的編輯器中進(jìn)行操作。

那這段代碼的問題是在哪里呢？

可以看到在channelDemo函數(shù)最后使用了一個(gè)sleep，這玩意在程序中可不能亂用。

說到這里給大家講一個(gè)小故事，咔咔之前在網(wǎng)上看到一段就是加了sleep的代碼。

然后一個(gè)新手程序員不明白為什么要加這個(gè)sleep，然后問題項(xiàng)目經(jīng)理，項(xiàng)目經(jīng)理說老板發(fā)現(xiàn)程序慢之后會(huì)找咱們優(yōu)化，每一次優(yōu)化把這個(gè)sleep的時(shí)間縮短即可。讓老板感覺到我們?cè)谧鍪虑椤?/p>

新手就是新手對(duì)不懂得代碼都會(huì)進(jìn)行標(biāo)注，然后就寫了一句注釋“項(xiàng)目經(jīng)理要求這里運(yùn)行緩慢，老板讓優(yōu)化時(shí)，代碼得到明顯的速度提升”。

這句話很不巧的是被老板給看見了，老板不認(rèn)識(shí)代碼，但文字還是認(rèn)識(shí)的哈！于是，項(xiàng)目經(jīng)理下馬。

所以說對(duì)于sleep大多數(shù)都是一個(gè)測(cè)試狀態(tài)，堅(jiān)決不會(huì)出現(xiàn)在線上的，所以呢？就要解決代碼中的這個(gè)sleep。

那么大家在回憶一下，在這里為什么要加sleep呢？

發(fā)送到channel的數(shù)據(jù)都是在另一個(gè)goroutine中進(jìn)行并發(fā)打印的，并發(fā)打印就會(huì)出現(xiàn)問題，因?yàn)楦静粫?huì)知道什么時(shí)候才打印完畢。

所以說這個(gè)sleep就會(huì)為了應(yīng)對(duì)這個(gè)不知道什么時(shí)候打印完的問題，給個(gè)1毫秒讓進(jìn)行打印。

這種做法是非常不好的，接下來看看使用一種新的方式來解決這個(gè)問題。

以下代碼是修改完的代碼。

package mainimport (
	"fmt")type worker struct {
	in   chan int
	done chan bool}func createWorker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWorker(id, w.in, w.done)
	return w}func doWorker(id int, c chan int, done chan bool) {
	for n := range c {
		fmt.Printf("Worker %d receive %c\n", id, n)
		done <- true
	}}func channelDemo() {
	var workers [10]worker	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i)
	}

	for i := 0; i < 10; i++ {
		workers[i].in <- 'a' + i		<-workers[i].done	}

	for i := 0; i < 10; i++ {
		workers[i].in <- 'A' + i		<-workers[i].done	}}func main() {
	channelDemo()}

將這些代碼復(fù)制到你的本地，然后再來看一下都做了什么改動(dòng)。

• 首先為了參數(shù)傳遞方便，建立了一個(gè)結(jié)構(gòu)體worker

• 并且把之前的worker方法改為了doWorker

• 這個(gè)時(shí)候createWorker方法返回值就不能是之前的channel了，而是創(chuàng)建的結(jié)構(gòu)體worker

• 然后在createWorker方法里邊把channel全部創(chuàng)建好。并且使用結(jié)構(gòu)體給doWorker傳遞參數(shù)。

• 最終返回的就是結(jié)構(gòu)體。

• 最后一步就是給channelDemo方法里邊發(fā)送數(shù)據(jù)的倆個(gè)循環(huán)里邊接收一下workers[i]的值即可。

看一下打印結(jié)果

是不是有點(diǎn)懵，這怎么成有序的了，如果是并行的那還有必要開那10個(gè)worker，直接按照順序打印就好了。

現(xiàn)在就來解決這個(gè)問題，我不希望發(fā)一個(gè)任務(wù)然后等它結(jié)束。

最好的就是把他們?nèi)堪l(fā)出去，等待它們?nèi)拷Y(jié)束再退出來。

代碼實(shí)現(xiàn)如下

package mainimport (
	"fmt")type worker struct {
	in   chan int
	done chan bool}func createWorker(id int) worker {
	w := worker{
		in:   make(chan int),
		done: make(chan bool),
	}
	go doWorker(id, w.in, w.done)
	return w}func doWorker(id int, c chan int, done chan bool) {
	for n := range c {
		fmt.Printf("Worker %d receive %c\n", id, n)
		done <- true
	}}func channelDemo() {
	var workers [10]worker	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i)
	}

	for i, worker := range workers {
		worker.in <- 'a' + i	}

	for i, worker := range workers {
		worker.in <- 'A' + i	}

	for _, worker := range workers {
		<-worker.done		<-worker.done	}}func main() {
	channelDemo()}

在這里再進(jìn)行打印看一下結(jié)果，你會(huì)發(fā)現(xiàn)代碼是有問題的。

為什么將小寫的字母打印出來，而打印大寫字母時(shí)發(fā)生了報(bào)錯(cuò)呢？

這個(gè)就要追溯到代碼中了，因?yàn)槲覀兇a本身就寫的有問題。

還是回歸到本文長(zhǎng)談的一個(gè)問題，那就是對(duì)于所有的channel有發(fā)送數(shù)據(jù)就必須有接收數(shù)據(jù)，如果沒有接收數(shù)據(jù)就會(huì)報(bào)錯(cuò)。

那么在代碼中你能看出是那塊只進(jìn)行了發(fā)送數(shù)據(jù)，而沒有接收數(shù)據(jù)嗎？

這個(gè)問題就是當(dāng)給channel把小寫字母發(fā)送了后，就會(huì)到進(jìn)入到doWorker方法，然后給done發(fā)送了一個(gè)true，但是接收done的方法是在后面，也就是說第二個(gè)發(fā)送大寫字母時(shí)，就會(huì)發(fā)送循環(huán)的等待。

解決這個(gè)問題也很簡(jiǎn)單，我們只需要并發(fā)的發(fā)送done即可。

看到打印結(jié)果也是正確的。

本文給的這個(gè)案例在一般項(xiàng)目中是不會(huì)出現(xiàn)的，所以說不用糾結(jié)于此。

給的案例就是為了讓大家更熟悉channel的機(jī)制而已。

對(duì)于這個(gè)解決方法還有一個(gè)方案解決，請(qǐng)看代碼。

將代碼還原到之前，然后在每一個(gè)發(fā)送字母的下面循環(huán)接收done即可。

對(duì)于這種多任務(wù)等待方式在go中有一個(gè)庫(kù)是可以來做這個(gè)事情，接下來看一下。

sync.WaitGroup的用法

對(duì)于sync.WaitGroup的用法咔咔就不一一介紹了，簡(jiǎn)單的看一下源碼的實(shí)現(xiàn)即可。

package mainimport (
	"fmt"
	"sync")type worker struct {
	in chan int
	wg *sync.WaitGroup}func createWorker(id int, wg *sync.WaitGroup) worker {
	w := worker{
		in: make(chan int),
		wg: wg,
	}
	go doWorker(id, w.in, wg)
	return w}func doWorker(id int, c chan int, wg *sync.WaitGroup) {
	for n := range c {
		fmt.Printf("Worker %d receive %c\n", id, n)
		wg.Done()
	}}func channelDemo() {
	var wg sync.WaitGroup	var workers [10]worker	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i, &wg)
	}
	// 添加20個(gè)任務(wù)
	wg.Add(20)
	for i, worker := range workers {
		worker.in <- 'a' + i	}
	for i, worker := range workers {
		worker.in <- 'A' + i	}
	wg.Wait()}func main() {
	channelDemo()}

這份源碼也是非常簡(jiǎn)單的，具體修改得東西咔咔簡(jiǎn)單介紹一下。

• 首先取消了channelDemo這個(gè)方法中關(guān)于done的channel。

• 使用了sync.WaitGroup，并且給createWorker方法傳遞sync.WaitGroup

• createWorker方法使用了 worker的結(jié)構(gòu)體。

• 所以要先修改worker結(jié)構(gòu)體，將之前的done改為wg *sync.WaitGroup即可

• 這樣就可以直接用結(jié)構(gòu)體的數(shù)據(jù)。

• 接著在doWorker方法中把最后一個(gè)參數(shù)done改為wg *sync.WaitGroup

• 將方法中的done改為wg.Done()

• 最后一步就是回到函數(shù)channelDemo中把任務(wù)數(shù)添加進(jìn)去，然后在代碼最后添加一個(gè)等待即可。

關(guān)于這塊的內(nèi)容先知道這么用即可，咔咔后期會(huì)慢慢的補(bǔ)充并且深入。

抽象代碼

這塊的代碼看起來不是那么的完美的，接下來抽象一下。

這塊代碼有沒有發(fā)現(xiàn)有點(diǎn)蹩腳，接下來我們使用函數(shù)式編程進(jìn)行簡(jiǎn)單的處理。

package mainimport (
	"fmt"
	"sync")type worker struct {
	in   chan int
	done func()}func createWorker(id int, wg *sync.WaitGroup) worker {
	w := worker{
		in: make(chan int),
		done: func() {
			wg.Done()
		},
	}
	go doWorker(id, w)
	return w}func doWorker(id int, w worker) {
	for n := range w.in {
		fmt.Printf("Worker %d receive %c\n", id, n)
		w.done()
	}}func channelDemo() {
	var wg sync.WaitGroup	var workers [10]worker	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i, &wg)
	}
	// 添加20個(gè)任務(wù)
	wg.Add(20)
	for i, worker := range workers {
		worker.in <- 'a' + i	}
	for i, worker := range workers {
		worker.in <- 'A' + i	}
	wg.Wait()}func main() {
	channelDemo()}

這塊代碼看不明白就先放著，寫的時(shí)間長(zhǎng)了，你就會(huì)明白其中的含義了，學(xué)習(xí)東西不要鉆牛角尖。

二、使用select進(jìn)行調(diào)度

開頭先給一個(gè)問題，假設(shè)現(xiàn)在有倆個(gè)channel，誰(shuí)來的快先收誰(shuí)應(yīng)該怎么做？

package mainimport (
	"fmt"
	"math/rand"
	"time")func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			// 隨機(jī)睡眠1500毫秒以內(nèi)
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			// 往out這個(gè)channel發(fā)送i值
			out <- i
			i++
		}
	}()
	return out}func main() {
	// 這里需要明白如果代碼為var c1, c2 chan int  則c1和c2都為nil
	// 在 select里面也是可以使用的，只不過是堵塞狀態(tài)！
	var c1, c2 = generator(), generator()
	for {
		/**
		select 方式進(jìn)行調(diào)度
		        使用場(chǎng)景：比如有多個(gè)通道，但我打算是哪一個(gè)通道先給我數(shù)據(jù)，我就先執(zhí)行誰(shuí)
		        這個(gè)select 可以是并行執(zhí)行 channel管道
		*/
		select {
		case n := <-c1:
			fmt.Printf("receive from c1 %d\n", n)
		case n := <-c2:
			fmt.Printf("receive from c2 %d\n", n)
		}
	}}

以上就是代碼實(shí)現(xiàn)，代碼注釋也寫的非常的清晰明了，就不過多的做解釋了。

主要用法還是對(duì)channel的使用，在帶上了一個(gè)新的概念select，可以在多個(gè)通道，那個(gè)通道先發(fā)送數(shù)據(jù)，就先執(zhí)行誰(shuí)，并且這個(gè)select也是可以并行執(zhí)行channel管道。

在上文寫的createWorker和worker倆個(gè)方法還記得吧！接下來就不在select里邊直接打印了。

就使用之前寫的倆個(gè)方法融合在一起，咔咔已將將源碼寫好了，接下來看一下實(shí)現(xiàn)。

package mainimport (
	"fmt"
	"math/rand"
	"time")func worker(id int, c chan int) {
	for n := range c {
		fmt.Printf("Worker %d receive %d\n", id, n)
	}}func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c}func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			// 隨機(jī)睡眠1500毫秒以內(nèi)
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			// 往out這個(gè)channel發(fā)送i值
			out <- i
			i++
		}
	}()
	return out}func main() {
	// 這里需要明白如果代碼為var c1, c2 chan int  則c1和c2都為nil
	// 在 select里面也是可以使用的，只不過是堵塞狀態(tài)！
	var c1, c2 = generator(), generator()
	// 直接調(diào)用createWorker方法，返回的就是一個(gè)channel
	w := createWorker(0)
	for {
		/**
		select 方式進(jìn)行調(diào)度
		        使用場(chǎng)景：比如有多個(gè)通道，但我打算是哪一個(gè)通道先給我數(shù)據(jù)，我就先執(zhí)行誰(shuí)
		        這個(gè)select 可以是并行執(zhí)行 channel管道
		*/
		select {
		case n := <-c1:
			w <- n		case n := <-c2:
			w <- n		}
	}}

運(yùn)行代碼

看到運(yùn)行結(jié)果得知也是沒有問題的。

這段代碼雖然運(yùn)行沒有任何問題，但是這樣有什么缺點(diǎn)呢？

可以看下這段代碼n := <-c1:這里先收了一個(gè)值，然后在下邊代碼w <- n又會(huì)阻塞住，這個(gè)是不好的。

那么希望是怎么執(zhí)行的呢？

這種模式是在select中既可以收數(shù)據(jù)，也可以發(fā)數(shù)據(jù)，目前這個(gè)程序是編譯不過的，請(qǐng)看修改后的源碼。

package mainimport (
	"fmt"
	"math/rand"
	"time")func worker(id int, c chan int) {
	for n := range c {
		fmt.Printf("Worker %d receive %d\n", id, n)
	}}func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c}func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			// 隨機(jī)睡眠1500毫秒以內(nèi)
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			// 往out這個(gè)channel發(fā)送i值
			out <- i
			i++
		}
	}()
	return out}func main() {
	// 這里需要明白如果代碼為var c1, c2 chan int  則c1和c2都為nil
	// 在 select里面也是可以使用的，只不過是堵塞狀態(tài)！
	var c1, c2 = generator(), generator()
	// 直接調(diào)用createWorker方法，返回的就是一個(gè)channel
	var worker = createWorker(0)
	// 這個(gè)n如果放在for循環(huán)里邊，就會(huì)一直打印0，因?yàn)閺腸1和c2收數(shù)據(jù)需要時(shí)間，所以會(huì)把0直接傳給worker
	n := 0
	// 使用這個(gè)標(biāo)識(shí)告訴有沒有值
	hasValue := false
	for {
		// 利用nil  channel的特性
		var activeWorker chan<- int
		if hasValue {
			activeWorker = worker		}
		/**
		select 方式進(jìn)行調(diào)度
		        使用場(chǎng)景：比如有多個(gè)通道，但我打算是哪一個(gè)通道先給我數(shù)據(jù)，我就先執(zhí)行誰(shuí)
		        這個(gè)select 可以是并行執(zhí)行 channel管道
		*/
		select {
		case n = <-c1:
			// 收到值的話就標(biāo)記為true
			hasValue = true
		case n = <-c2:
			// 收到值的話就標(biāo)記為true
			hasValue = true
		case activeWorker <- n:
			hasValue = false
		}
	}}

這個(gè)模式還是有缺點(diǎn)的，因?yàn)閚收c1和c2的速度跟消耗的速度是不一樣的。

假設(shè)c1的生成速度特別快，一下子生成了1,2，3。那么最后輸出的數(shù)據(jù)有可能就只有3，而1和2就無法輸出了。

這個(gè)場(chǎng)景也是非常好模擬的，只需要在打印的位置加上一點(diǎn)延遲時(shí)間即可。

此時(shí)你會(huì)看到運(yùn)行結(jié)果為0、7、12、20…中間很多的數(shù)字都沒來得急打印。

因此我們就需要把收到的n存下來進(jìn)行排隊(duì)輸出。

package mainimport (
	"fmt"
	"math/rand"
	"time")func worker(id int, c chan int) {
	for n := range c {
		// 手動(dòng)讓消耗速度變慢
		time.Sleep(5 * time.Second)
		fmt.Printf("Worker %d receive %d\n", id, n)
	}}func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c}func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			// 隨機(jī)睡眠1500毫秒以內(nèi)
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			// 往out這個(gè)channel發(fā)送i值
			out <- i
			i++
		}
	}()
	return out}func main() {
	// 這里需要明白如果代碼為var c1, c2 chan int  則c1和c2都為nil
	// 在 select里面也是可以使用的，只不過是堵塞狀態(tài)！
	var c1, c2 = generator(), generator()
	// 直接調(diào)用createWorker方法，返回的就是一個(gè)channel
	var worker = createWorker(0)
	// 用來收n的值
	var values []int
	for {
		// 利用nil  channel的特性
		var activeWorker chan<- int
		var activeValue int
		// 判斷當(dāng)values中有值時(shí)
		if len(values) > 0 {
			activeWorker = worker			// 取出索引為0的值
			activeValue = values[0]
		}
		/**
		select 方式進(jìn)行調(diào)度
		        使用場(chǎng)景：比如有多個(gè)通道，但我打算是哪一個(gè)通道先給我數(shù)據(jù)，我就先執(zhí)行誰(shuí)
		        這個(gè)select 可以是并行執(zhí)行 channel管道
		*/
		select {
		case n := <-c1:
			// 將收到的數(shù)據(jù)存到values中
			values = append(values, n)
		case n := <-c2:
			// 將收到的數(shù)據(jù)存到values中
			values = append(values, n)
		case activeWorker <- activeValue:
			// 送出去后就需要把values中的第一個(gè)值拿掉
			values = values[1:]
		}
	}}

以上就是實(shí)現(xiàn)代碼

此時(shí)在來看運(yùn)行結(jié)果。

運(yùn)行結(jié)果沒有漏掉數(shù)據(jù)，并且也是無序的，這樣就非常好了。

計(jì)時(shí)器的使用

上面的這個(gè)程序是退出不了的，我們想讓它10s后就直接退出怎么做呢？

那就需要使用計(jì)時(shí)器來進(jìn)行操作了。

package mainimport (
	"fmt"
	"math/rand"
	"time")func worker(id int, c chan int) {
	for n := range c {
		// 手動(dòng)讓消耗速度變慢
		time.Sleep(time.Second)
		fmt.Printf("Worker %d receive %d\n", id, n)
	}}func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c}func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			// 隨機(jī)睡眠1500毫秒以內(nèi)
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			// 往out這個(gè)channel發(fā)送i值
			out <- i
			i++
		}
	}()
	return out}func main() {
	// 這里需要明白如果代碼為var c1, c2 chan int  則c1和c2都為nil
	// 在 select里面也是可以使用的，只不過是堵塞狀態(tài)！
	var c1, c2 = generator(), generator()
	// 直接調(diào)用createWorker方法，返回的就是一個(gè)channel
	var worker = createWorker(0)
	// 用來收n的值
	var values []int
	// 返回的是一個(gè)channel
	tm := time.After(10 * time.Second)
	for {
		// 利用nil  channel的特性
		var activeWorker chan<- int
		var activeValue int
		// 判斷當(dāng)values中有值時(shí)
		if len(values) > 0 {
			activeWorker = worker			// 取出索引為0的值
			activeValue = values[0]
		}
		/**
		select 方式進(jìn)行調(diào)度
		        使用場(chǎng)景：比如有多個(gè)通道，但我打算是哪一個(gè)通道先給我數(shù)據(jù)，我就先執(zhí)行誰(shuí)
		        這個(gè)select 可以是并行執(zhí)行 channel管道
		*/
		select {
		case n := <-c1:
			// 將收到的數(shù)據(jù)存到values中
			values = append(values, n)
		case n := <-c2:
			// 將收到的數(shù)據(jù)存到values中
			values = append(values, n)
		case activeWorker <- activeValue:
			// 送出去后就需要把values中的第一個(gè)值拿掉
			values = values[1:]
		case <-tm:
			fmt.Println("Bye")
			return
		}
	}}

這里就是源碼的實(shí)現(xiàn)，可以看到直接在select中是可以收到tm的值的，也就說如果到了10s，就會(huì)執(zhí)行打印bye的操作。

那么現(xiàn)在還有另外一個(gè)需求，就是如果在800毫秒的時(shí)間內(nèi)還沒有收到數(shù)據(jù)，可以做其它事情。

使用舉一反三的思想，你可以思考一下這件事情應(yīng)該怎么做。

其實(shí)也就很簡(jiǎn)單了，只需要在case中在設(shè)置一個(gè)定時(shí)器即可。

既然說到了這里就在給大家補(bǔ)充一個(gè)用法tick := time.Tick(time.Second)

同樣也是在case中使用。

這樣就可以每秒來顯示一下values隊(duì)列有多少數(shù)據(jù)。

這塊的內(nèi)容就結(jié)束了，最終給大家發(fā)一下源碼，感興趣的可以在自己的編輯器上試試看。

package mainimport (
	"fmt"
	"math/rand"
	"time")func worker(id int, c chan int) {
	for n := range c {
		// 手動(dòng)讓消耗速度變慢
		time.Sleep(time.Second)
		fmt.Printf("Worker %d receive %d\n", id, n)
	}}func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c}func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			// 隨機(jī)睡眠1500毫秒以內(nèi)
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			// 往out這個(gè)channel發(fā)送i值
			out <- i
			i++
		}
	}()
	return out}func main() {
	// 這里需要明白如果代碼為var c1, c2 chan int  則c1和c2都為nil
	// 在 select里面也是可以使用的，只不過是堵塞狀態(tài)！
	var c1, c2 = generator(), generator()
	// 直接調(diào)用createWorker方法，返回的就是一個(gè)channel
	var worker = createWorker(0)
	// 用來收n的值
	var values []int
	// 返回的是一個(gè)channel
	tm := time.After(10 * time.Second)
	tick := time.Tick(time.Second)
	for {
		// 利用nil  channel的特性
		var activeWorker chan<- int
		var activeValue int
		// 判斷當(dāng)values中有值時(shí)
		if len(values) > 0 {
			activeWorker = worker			// 取出索引為0的值
			activeValue = values[0]
		}
		/**
		select 方式進(jìn)行調(diào)度
		        使用場(chǎng)景：比如有多個(gè)通道，但我打算是哪一個(gè)通道先給我數(shù)據(jù)，我就先執(zhí)行誰(shuí)
		        這個(gè)select 可以是并行執(zhí)行 channel管道
		*/
		select {
		case n := <-c1:
			// 將收到的數(shù)據(jù)存到values中
			values = append(values, n)
		case n := <-c2:
			// 將收到的數(shù)據(jù)存到values中
			values = append(values, n)
		case activeWorker <- activeValue:
			// 送出去后就需要把values中的第一個(gè)值拿掉
			values = values[1:]
		case <-time.After(800 * time.Millisecond):
			// 如果在800毫秒沒有收到數(shù)據(jù)則提示超時(shí)
			fmt.Println("timeout")
		case <-tick:
			// 每秒獲取一下values中隊(duì)列的長(zhǎng)度
			fmt.Println("queue len = ", len(values))
		case <-tm:
			fmt.Println("Bye")
			return
		}
	}}

關(guān)于“Go中怎么使用channel”這篇文章就分享到這里了，希望以上內(nèi)容可以對(duì)大家有一定的幫助，使各位可以學(xué)到更多知識(shí)，如果覺得文章不錯(cuò)，請(qǐng)把它分享出去讓更多的人看到。