Channel的基本概念
Channal就是用来通信的，像Unix下的管道一样,
它的操作符是箭头" <-" , 箭头的指向就是数据的流向
ch <- v // 发送值v到Channel ch中
v := <-ch // 从Channel ch中接收数据，并将数据赋值给v
下面的程序演示了一个goroutine和主程序通信的例程。
package main
import "fmt"
func main() {
//创建一个string类型的channel
channel := make(chan string)
//创建一个goroutine向channel里发一个字符串
go func() { channel <- "hello" }()
msg := <- channel
fmt.Println(msg)
}
chan为先入先出的队列,有三种类型,双向,只读,只写,分别为"chan","chan<-","<-chan"
初始化时候,可以指定容量make(chanint,100);容量(capacity)代表Channel容纳的最多的元素的数量
Channel的阻塞
channel默认上是阻塞的，也就是说，如果Channel满了，就阻塞写，如果Channel空了，就阻塞读。于是，我们就可以使用这种特性来同步我们的发送和接收端。
package main
import "fmt"
import "time"
func main() {
channel := make(chan string) //注意: buffer为1
go func() {
channel <- "hello"
fmt.Println("write \"hello\" done!")
channel <- "World" //Reader在Sleep，这里在阻塞
fmt.Println("write \"World\" done!")
fmt.Println("Write go sleep...")
time.Sleep(3*time.Second)
channel <- "channel"
fmt.Println("write \"channel\" done!")
}()
time.Sleep(2*time.Second)
fmt.Println("Reader Wake up...")
msg := <-channel
fmt.Println("Reader: ", msg)
msg = <-channel
fmt.Println("Reader: ", msg)
msg = <-channel //Writer在Sleep，这里在阻塞
fmt.Println("Reader: ", msg)
}
结果为
Reader Wake up...
Reader: hello
write "hello" done!
write "World" done!
Write go sleep...
Reader: World
write "channel" done!
Reader: channel
总结
- channel的定义
- 定义语法 ：
- var ch =make(chan 通道中传递的数据类型，容量大小) 0为无缓冲，其余为有缓冲
- 读channel：
- <-ch 读到数据抛空，用来调节各个go程的先后顺序
- num := <-ch 读到数据，存入num中
- 写channel：
- ch <- data data类型严格于定义的语法一致
- 特性：
- 通道中的数据只能单向流动。一端读端，另一端必须写端。
- 通道中的数据只能一次读取，不能重复读。
- 读端和写端在不同的go程之间
- 读端读，写端不在写，读端阻塞。写端写，读端不在线，写端阻塞。
- 系统3个特殊文件：
- stdin：标准输入文件 ---键盘
- stdout：标准输出文件 ---屏幕
- stderr：标准错误文件 ---屏幕
- 定义语法 ：
- channel分类
- 无缓冲
- 要求 读端写端同时在线，对端不在线，本端阻塞
- 有缓冲
- 读端，不在线，写端可以将数据直接写入缓冲区(不阻塞) 直到缓冲区被写满，依然没有读端，写端阻塞
- 无缓冲
go程间通信
- 多个go程间，如果有多个共享资源时，需要分别同步
同步通信，异步通信
- 同步通信：——无缓冲channel
- 一个调用发出，如果没有得到结果，那么该调用不返回 ——阻塞
- 异步通信：
- 一个调用发出，不等待结果，直接返回——不阻塞
关闭channel
当写端，写完数据后，使用close(ch)关闭channel
读端，可以判断channel是否可读
for{ if num,ok:= <-ch;ok{ fmt.Println("num=",num)//读ch中的数据 }else{ break //跳出数据 } } // 读channel的内容，结束后自动跳出 // 是上面一种的简单写法 for num := range ch{ }
-
关闭channel的特性：
- 如果写端没有关闭，暂停写入，读端阻塞等待
- 如果写端已经关闭，不能写入，报错：==panic：send on closed channel==
- 如果写端已经关闭，读端依然能读取，读到的是数据类型的零值
单向channel
- 定义语法：
- 双向channel：
- var ch chan 数据类型
- 单向读channel：
- var chr <- chan int
- chr = ch 双向channel给单向读channel赋值
- 只能做读操作不能做写操作
- 单向写channel:
- var chw chan <- int
- chw = ch 双向channel给单向写channel赋值
- 只能做写操作不能做读操作
- 双向channel：
- 单向channel==不能==给双向channel赋值
- 单向channel的使用：
- 主要应用于函数传参，单向channel可以在语法层面限定channel使用的方法
- 单向读：不能写
- 单向写：不能读
- 主要应用于函数传参，单向channel可以在语法层面限定channel使用的方法
Select关键字
多个Channel的select
package main
import "time"
import "fmt"
func main() {
//创建两个channel - c1 c2
c1 := make(chan string)
c2 := make(chan string)
//创建两个goruntine来分别向这两个channel发送数据
go func() {
time.Sleep(time.Second * 1)
c1 <- "Hello"
}()
go func() {
time.Sleep(time.Second * 1)
c2 <- "World"
}()
//使用select来侦听两个channel
for i := 0; i < 2; i++ {
select {
case msg1 := <-c1:
fmt.Println("received", msg1)
case msg2 := <-c2:
fmt.Println("received", msg2)
}
}
}
select的使用
- 作用：用来监听channel上的数据流动
- 特性：
- 每一个case分支，都必须是IO操作
- 通常将select置于for循环中
- 一个case监听的channel不满足监听条件，当前case分支阻塞
- 当所有case分支都不满足监听条件时，select如果有default分支时，走default，否则等待case满足
- 当监听的多个case分支中，同时满足多个case，随机选择任意一个执行
- 为防止忙轮询出现，可以适当选择省略default
- break关键字不能应用于结束整个select，只能跳出一个分支
- ==结论==：所有使用select的go程，与其他go程间，通信时，采用的是==异步通信==
