channel是goroutine之间互相通讯的东西。类似我们Unix上的管道（可以在进程间传递消息）， 用来goroutine之间发消息和接收消息。其实，就是在做goroutine之间的内存共享。
channel.png
一上来就给大家搞了张图片，我们可以看到goroutine与goroutine之间的双向的通道就是channel，那么这一节我们就来详细的讲一下这个channel，我们先来讲语法然后在讲具体的实例。
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
c := make(chan int) // 我们现在做一个chan就可以直接使用了
c <- 1
c <- 2
n := <- c
fmt.Println(n) // 结果报错了，fatal error: all goroutines are asleep - deadlock!
}
func main() {
chanDemo()
}
这个时候会有死锁，这是为什么呢？，这是因为goroutine与goroutine是双向的交互，如果我们只发不收没有收的就会出现deadlock那么我们怎么收呢？我们开一个goroutine去收
package main
import "fmt"
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
c := make(chan int) // 我们现在做一个chan就可以直接使用了
go func() {
for {
n := <-c
fmt.Println(n) // 结果是1
}
}()
c <- 1
c <- 2
}
func main() {
chanDemo()
}
那么为什么这里只有一个1呢？其实原理与上一个有点像，其实当我们执行fmt.Println(2)的时候，整个chanDemo()函数已经退掉了，就是说它还没来得及打印，那么我们先来个很简单的解决办法，直接
func chanDemo() {
// var c chan int // c == nil
c := make(chan int) // 我们现在做一个chan就可以直接使用了
go func() {
for {
n := <-c
fmt.Println(n)
}
}()
c <- 1
c <- 2
time.Sleep(time.Millisecond)
}
我会在后面给大家讲解如何协作，我们下面说的事情与函数式编程有点像，Go语言里面函数是一等公民，可以是参数可以是返回值。我们的chan也是一等公民，也可以是参数可以是返回值，那么我们来操作一把！！！
package main
import (
"fmt"
"time"
)
func worker(c chan int) {
for {
n := <-c
fmt.Println(n) // 1,2
}
}
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
c := make(chan int) // 我们现在做一个chan就可以直接使用了
go worker(c)
c <- 1
c <- 2
time.Sleep(time.Millisecond)
}
func main() {
chanDemo()
}
我们把goroutine拿出去，放到work里面，把这个chan当作一个参数穿进去，是不是很有意思呢？我们在放个id进去看看怎么样
func worker(id int, c chan int) {
for {
fmt.Printf("Worker %d received %d\n",
id, <-c)
}
}
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
c := make(chan int) // 我们现在做一个chan就可以直接使用了
go worker(0, c)
c <- 1
c <- 2
time.Sleep(time.Millisecond)
}
结果就是
Worker 0 received 1
Worker 0 received 2
那么如果我们一口气开10个work会怎么样呢？往下看
func worker(id int, c chan int) {
for {
fmt.Printf("Worker %d Received %c\n",
id, <-c)
}
}
func chanDemo() {
// var c chan int // c == nil
var channels [10]chan int
for i := 0; i < 10; i++ {
channels[i] = make(chan int) // 我们现在做一个chan就可以直接使用了
go worker(i, channels[i])
}
for i := 0; i < 10; i++ {
channels[i] <- 'a' + i
}
time.Sleep(time.Millisecond)
}
我们建了一个数组，数组里面每个人都是一个channel，我们分别把10个channel分发给10个channel，然后给这10个人分别发一些数据。
结果就是，大家可以先想一下是什么，在往下看。。。。。。
Worker 0 Received a
Worker 2 Received c
Worker 4 Received e
Worker 7 Received h
Worker 3 Received d
Worker 1 Received b
Worker 8 Received i
Worker 9 Received j
Worker 6 Received g
Worker 5 Received f
我们只打这些还不过瘾，我们还可以在加一个for循环，这次我们来打A
func chanDemo() {
// var c chan int // c == nil
var channels [10]chan int
for i := 0; i < 10; i++ {
channels[i] = make(chan int) // 我们现在做一个chan就可以直接使用了
go worker(i, channels[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)
}
由于长度的原因，😄我这里把结果只贴出来几个
Worker 2 Received c
Worker 1 Received b
Worker 1 Received B
Worker 0 Received A
Worker 8 Received I
为什么这里的顺序是乱的呢？这是因为我们在fmt打印的时候是I/O操作，调度器会自动去调度。
我们再来看一下，chan作为返回值的时候是什么样子的。。。。
func createWorker(id int) chan int {
c := make(chan int)
go func() {
for {
fmt.Printf("Worker %d Received %c\n",
id, <-c)
}
}()
return c
}
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
var channels [10]chan int
for i := 0; i < 10; i++ {
channels[i] = createWorker(i) // 我们现在做一个chan就可以直接使用了
}
for i := 0; i < 10; i++ {
channels[i] <- 'a' + i
}
for i := 0; i < 10; i++ {
channels[i] <- 'A' + i
}
time.Sleep(time.Millisecond)
}
这里的结果是一样的。。。。怎么样还不错把！
但是这个地方呢，我们要告诉外面我们返回的chan应该怎么用呢？我们加个箭头，比如。。。。。
func createWorker(id int) chan<-int {
c := make(chan int)
// 这里如果不加程序就死循环一直收，而且也没有人发数据，就死掉了。
go func() {
for {
fmt.Printf("Worker %d Received %c\n",
id, <-c)
}
}()
return c
}
func chanDemo() {
var channels [10]chan <-int
长度原因只给大家部分代码，为了是让大家可以运行起来。
我们再来介绍一个bufferedChannel
func bufferedChannel() {
c := make(chan int, 3)
c <- 1
c <- 2
c <- 3
}
func main() {
//chanDemo()
bufferedChannel()
}
有时候我们每次都切换，也太浪费资源我们想先把它放进一个缓存区，我们设置了缓存区为3，那么我们在执行就不会报错了，输出了1，2， 3
func worker(id int, c chan int) {
for {
fmt.Printf("Worker %d Received %c\n",
id, <-c)
}
}
func createWorker(id int) chan<- int {
c := make(chan int)
// 这里如果不加程序就死循环一直收，而且也没有人发数据，就死掉了。
go worker(id, c)
return c
}
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
var channels [10]chan<- int
for i := 0; i < 10; i++ {
channels[i] = createWorker(i) // 我们现在做一个chan就可以直接使用了
}
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 bufferedChannel() {
c := make(chan int, 3)
go worker(0, c)
c <- 'a'
c <- 'b'
c <- 'c'
time.Sleep(time.Millisecond)
}
func main() {
//chanDemo()
bufferedChannel()
}
我们这样使用了缓存区，这样对于提升性能帮助也是蛮大的。。。。。
其实，channel也是可以close的,我们一般都是发送方要通知接收方我没有数据要发了,这里我们使用两个方法进行判断是否还有数据一个是range一个是ok
package main
import (
"fmt"
"time"
)
func worker(id int, c chan int) {
for n := range c {
fmt.Printf("Worker %d Received %d\n",
id, n)
}
//for {
// // 通过ok，来判断是否有数据
// n, ok := <-c
// if !ok {
// break
// }
// 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
}
// 定义一个chan 内容是int类型
func chanDemo() {
// var c chan int // c == nil
var channels [10]chan<- int
for i := 0; i < 10; i++ {
channels[i] = createWorker(i) // 我们现在做一个chan就可以直接使用了
}
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 bufferedChannel() {
c := make(chan int, 3)
go worker(0, c)
c <- 'a'
c <- 'b'
c <- 'c'
time.Sleep(time.Millisecond)
}
func channelClose() {
c := make(chan int)
go worker(0, c)
c <- 'a'
c <- 'b'
c <- 'c'
close(c)
time.Sleep(time.Millisecond)
}
func main() {
//chanDemo()
//bufferedChannel()
channelClose()
}
上面这些就是讲的一些channel的语法
- channel
- buffered channel
- range
- 理论基础： Communication Sequential Process(CSP)
我们只是讲了一些channel的语法,很多小伙伴可能不知道是做什么用的，接下来的章节我们就来看看怎么用这些知识。。。。。。
最后送给小伙伴们一句，Go语言创始人的一句话
不用通过共享内存来通信；通过通信来共享内存
