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类型严格于定义的语法一致
  • 特性：
    1. 通道中的数据只能单向流动。一端读端，另一端必须写端。
    2. 通道中的数据只能一次读取，不能重复读。
    3. 读端和写端在不同的go程之间
    4. 读端读，写端不在写，读端阻塞。写端写，读端不在线，写端阻塞。
  • 系统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使用的方法
    • 单向读：不能写
    • 单向写：不能读

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程间，通信时，采用的是==异步通信==