go routine channel select

一、go routine channel

package main

import (
	"fmt"
	"time"
)

func worker(id int, c chan int) {
	for n := range c {//读取channel
		fmt.Printf("Worker %d received %c\n",
			id, n)
	}
}

func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)//routine，可以理解为新开线程
	return c
}

func chanDemo() {
	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//向channel中写入数据
	}

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

	time.Sleep(time.Second)//主线程也是个runtine
}

func bufferedChannel() {
	c := make(chan int, 3)
	go worker(0, c)
	c <- 'a'
	c <- 'b'
	c <- 'c'//如果没有人接收，可以在缓冲区存放3个，发送第四个时候会阻塞；如果make(chan int)，如果没有人接收，在发送第二个时候，就会阻塞。
	c <- 'd'
	time.Sleep(time.Millisecond)
}

func channelClose() {
	c := make(chan int)
	go worker(0, c)
	c <- 'a'
	c <- 'b'
	c <- 'c'
	c <- 'd'
	close(c)//关闭channel后不能发送和接收数据了
	time.Sleep(time.Second * 20)
}

func main() {
	fmt.Println("Channel as first-class citizen")
	chanDemo()
	//fmt.Println("Buffered channel")
	//bufferedChannel()
	//fmt.Println("Channel close and range")
	//channelClose()
}

输出：

Worker 0 received a
Worker 1 received b
Worker 2 received c
Worker 3 received d
Worker 4 received e
Worker 4 received E
Worker 0 received A
Worker 7 received h
Worker 2 received C
Worker 9 received j
Worker 1 received B
Worker 6 received g
Worker 3 received D
Worker 8 received i
Worker 5 received f
Worker 5 received F
Worker 8 received I
Worker 6 received G
Worker 7 received H
Worker 9 received J
go runtine可以理解为新开个线程，不过实际上很多runtime可以运行在一个线程中，由go虚拟机去调度。

go channel是为了不同go runtine间通信而设置的。

1、发送channel后，只能在其他runtine中接收到channel后，才会继续执行下条语句，否则在发送channel时睡眠等待

2、如果是接收channel，如果没有发送者，则会一直等待，直到发送channel。

package main

import (
	"fmt"
	"time"
)

func worker(id int, c chan int) {
	time.Sleep(time.Second * 5)
	for n := range c {
		fmt.Printf("Worker %d received %c\n",
			id, n)
	}
}

func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c
}


func channelClose() {
	c := make(chan int)
	go worker(0, c)
	c <- 'a'//发送channel后，只能在其他runtine中接收到channel后，才会继续执行下条语句，否则在发送channel时睡眠等待
	fmt.Println("run here")
	c <- 'b'
	c <- 'c'
	c <- 'd'
	time.Sleep(time.Second * 20)
}

func main() {
	fmt.Println("Channel close and range")
	channelClose()
}

先睡眠等待5秒后，才打印run here。

二、channel完整例子

package main

import (
	"fmt"
)

func doWork(id int,
	w worker) {
	for n := range w.in {
		fmt.Printf("Worker %d received %c\n",
			id, n)
		w.done <- true
	}
}

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 doWork(id, w)
	return w
}

func chanDemo() {

	var workers [10]worker
	for i := 0; i < 10; i++ {
		workers[i] = createWorker(i)
	}


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

	for _, worker := range workers {
		<-worker.done
	}

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

	for _, worker := range workers {
		<-worker.done
	}
}

func main() {
	chanDemo()
}

输出：

Worker 9 received j
Worker 8 received i
Worker 7 received h
Worker 0 received a
Worker 2 received c
Worker 1 received b
Worker 3 received d
Worker 5 received f
Worker 6 received g
Worker 4 received e
Worker 1 received B
Worker 0 received A
Worker 3 received D
Worker 2 received C
Worker 4 received E
Worker 5 received F
Worker 9 received J
Worker 8 received I
Worker 6 received G
Worker 7 received H

package main

import (
	"fmt"
)

func doWork(id int,
	w worker) {
	for n := range w.in {
		fmt.Printf("Worker %d received %c\n",
			id, n)
		w.done <- true//没有人接收，会卡在这句上，而马上又要发送channel，接收的语句还在发送channel后面，死锁
	}
}

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 doWork(id, w)
	return w
}

func chanDemo() {

	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() {
	chanDemo()
}

输出：

Worker 8 received i
Worker 9 received j
Worker 1 received b
Worker 3 received d
Worker 5 received f

Worker 4 received e
Worker 6 received g
Worker 2 received c
Worker 0 received a
fatal error: all goroutines are asleep - deadlock!
 

三、select

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(1500))* time.Millisecond)
			out <- i
			i++
		}
	}()
	return out
}

func main() {
	var c1 ,c2 = generator(), generator()
	var c3 chan int
	c3 = make(chan int)
	for {
		select {
		case n := <-c1:
			fmt.Println("Received from c1:", n)
		case n := <-c2:
			fmt.Println("Received from c2:", n)
		case c3 <- 1:
			fmt.Println("send c3:")
		}
	}


}

select和不加select有什么区别呢？

不加select:

如果接收时，没有人发送，会睡眠等待，如n := <-c1。如果发送，没有人接收，会睡眠等待如c3 <- 1。

加select：

如果接收时，没有人发送，会继续向下匹配，如n := <-c1。如果发送，没有人接收，会继续向下匹配如c3 <- 1。

如果全部没有匹配，会睡眠等待，直到有匹配项过来。如果有default，则走default，不会睡眠等待。

如果接收时，有人发送，匹配成功，进入case内语句执行后，继续下一轮匹配，如n := <-c1。

如果发送，有人接收，匹配成功，进入case内语句执行后，会继续向下匹配如c3 <- 1。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func generator() chan int {
	out := make(chan int)
	go func() {
		i := 0
		for {
			time.Sleep(
				time.Duration(rand.Intn(1500)) *
					time.Millisecond)
			out <- i
			i++
		}
	}()
	return out
}

func worker(id int, c chan int) {
	for n := range c {
		time.Sleep(time.Second)
		fmt.Printf("Worker %d received %d\n",
			id, n)
	}
}

func createWorker(id int) chan<- int {
	c := make(chan int)
	go worker(id, c)
	return c
}

func main() {
	var c1, c2 = generator(), generator()
	var worker = createWorker(0)

	var values []int
	tm := time.After(10 * time.Second)
	for {
		var activeWorker chan<- int
		var activeValue int
		if len(values) > 0 {
			activeWorker = worker
			activeValue = values[0]
		}

		select {
		case n := <-c1:
			values = append(values, n)
			fmt.Println("set values：", values)
		case n := <-c2:
			values = append(values, n)
			fmt.Println("set values：", values)
		case activeWorker <- activeValue:
			values = values[1:]
			fmt.Println("get values：", values)
		case <-tm:
			fmt.Println("bye")
			return
		}
	}
}

输出：

//刚开始没有c1和c2没有接受到数据时，由于activeWorker是nil chan，所以此时会睡眠，但在select的时候直接跳过。如果所有case都不匹配，那么就睡眠了。

第一轮：---睡眠等待---

之后每次匹配所有项，如果c1和c2有人写，activeWorker有值并且读端正在等待读，则执行case；如果都不匹配，那么就睡眠等待直到匹配，再执行下一轮循环把数据拿出来。

第二轮：set values： [0] //从c1获取数据
第三轮：get values： [] //activeWorker有值，向其中写入数据，并且读端正在等待读，此时可写入数据，执行case语句

第四轮：---睡眠等待---
第五轮：set values： [0] //从c2获取数据
第六轮：set values： [0 1]

第七轮：---睡眠等待---
第八轮：set values： [0 1 1]

第九轮：---睡眠等待---
第十轮：set values： [0 1 1 2]

第十一轮：---睡眠等待---
Worker 0 received 0 //读端结束sleep，继续等待读状态，for n := range c {
第十二轮get values： [1 1 2] //activeWorker有值，向其中写入数据，并且读端正在等待读，此时可写入数据，执行case语句
set values： [1 1 2 2]
set values： [1 1 2 2 3]
Worker 0 received 0
get values： [1 2 2 3]
set values： [1 2 2 3 3]
set values： [1 2 2 3 3 4]
set values： [1 2 2 3 3 4 5]
Worker 0 received 1
get values： [2 2 3 3 4 5]
set values： [2 2 3 3 4 5 4]
set values： [2 2 3 3 4 5 4 5]
set values： [2 2 3 3 4 5 4 5 6]
set values： [2 2 3 3 4 5 4 5 6 6]
Worker 0 received 1
get values： [2 3 3 4 5 4 5 6 6]
set values： [2 3 3 4 5 4 5 6 6 7]
set values： [2 3 3 4 5 4 5 6 6 7 7]
Worker 0 received 2
get values： [3 3 4 5 4 5 6 6 7 7]
set values： [3 3 4 5 4 5 6 6 7 7 8]
set values： [3 3 4 5 4 5 6 6 7 7 8 9]
Worker 0 received 2
get values： [3 4 5 4 5 6 6 7 7 8 9]
set values： [3 4 5 4 5 6 6 7 7 8 9 8]
Worker 0 received 3
get values： [4 5 4 5 6 6 7 7 8 9 8]
set values： [4 5 4 5 6 6 7 7 8 9 8 10]
set values： [4 5 4 5 6 6 7 7 8 9 8 10 9]
Worker 0 received 3
get values： [5 4 5 6 6 7 7 8 9 8 10 9]
set values： [5 4 5 6 6 7 7 8 9 8 10 9 11]
set values： [5 4 5 6 6 7 7 8 9 8 10 9 11 10]
Worker 0 received 4
get values： [4 5 6 6 7 7 8 9 8 10 9 11 10]
set values： [4 5 6 6 7 7 8 9 8 10 9 11 10 11]
set values： [4 5 6 6 7 7 8 9 8 10 9 11 10 11 12]
bye