Golang学习笔记：channel

channel

channel是goroutine之间的通讯机制，它可让一个goroutine经过它给另外一个goroutine发送数据，每一个channel在建立的时候必须指定一个类型，指定的类型是任意的。
使用内置的make函数，能够建立一个channel类型：

ch := make(chan int)

发送和接受

channel主要的操做有发送和接受：

// 发送数据到channel
ch <- 1
// 从channel接受数据
x := <- ch

如向channel发送数据的时候，该goroutine会一直阻塞直到另外一个goroutine接受该channel的数据，反之亦然，goroutine接受channel的数据的时候也会一直阻塞直到另外一个goroutine向该channel发送数据，以下面操做：

func main() {
    ch := make(chan string)
    // 在此处阻塞，而后程序会弹出死锁的报错
    c <- "hello"
    fmt.Println("channel has send data")
}

正确的操做：

func main() {
    ch := make(chan string)
    go func(){
        // 在执行到这一步的时候main goroutine才会中止阻塞
        str := <- ch
        fmt.Println("receive data：" + str)
    }()
    ch <- "hello"
    fmt.Println("channel has send data")
}

说到channel的阻塞，就不得不说到有缓冲的channel。

带缓冲的channel

带缓冲的channel的建立和不带缓冲的channel（也就是上面用的channel）的建立差很少，只是在make函数的第二个参数指定缓冲的大小。

// 建立一个容量为10的channel
ch := make(chan int, 10)

带缓冲的channel就像一个队列，听从先进先从的原则，发送数据向队列尾部添加数据，从头部接受数据。

goroutine向channel发送数据的时候若是缓冲还没满，那么该goroutine就不会阻塞。

ch := make(chan int, 2)
// 前面两次发送数据不会阻塞，由于缓冲还没满
ch <- 1
ch <- 2
// goroutine会在这里阻塞
ch <- 3

反之若是接受该channel数据的时候，若是缓冲有数据，那么该goroutine就不会阻塞。

channel与goroutine之间的应用能够想象成某个工厂的流水线工做，流水线上面有打磨，上色两个步骤（两个goroutine），负责打磨的工人生产完成后会传给负责上色的工人，上色的生产依赖于打磨，两个步骤之间的可能存在存放槽（channel），若是存放槽存满了，打磨工人就不能继续向存放槽当中存放产品，直到上色工人拿走产品，反之上色工人若是把存放槽中的产品都上色完毕，那么他就只能等待新的产品投放到存放槽中。

备注

其实在实际应用中，带缓冲的channel用的并很少，继续拿刚才的流水线来作案例，若是打磨工人生产速度比上色工人工做速度要快，那么即使再多容量的channel，也会早晚被填满而后打磨工人会被阻塞，反之若是上色工人生产速度大于打磨工人速度，那么有缓冲的channel也是一直处于没有数据，上色工人很容易长时间处于阻塞的状态。

所以比较好的解决方法仍是针对生产速度较慢的一方多加人手，也就是多开几个goroutine来进行处理，有缓冲的channel最好用处只是拿来防止goroutine的完成时间有必定的波动，须要把结果缓冲起来，以平衡总体channel通讯。

单方向的channel

使用channel来使不一样的goroutine去进行通讯，不少时候都和消费者生产者模式很类似，一个goroutine生产的结果都用channel传送给另外一个goroutine，一个goroutine的执行依赖与另外一个goroutine的结果。
所以不少状况下，channel都是单方向的，在go里面能够把一个无方向的channel转换为只接受或者只发送的channel，可是却不能反过来把接受或发送的channel转换为无方向的channel，适当地把channel改为单方向，能够达到程序强约束的作法，相似于下面例子：

fuc main(){
    ch := make(ch chan string)
    
    go func(out chan<- string){
        out <- "hello"
    }(ch)
    
    go func(in <-chan string){
        fmt.Println(in)
    }(ch)
    
    time.Sleep(2 * time.Second)
}

select多路复用

在一个goroutine里面，对channel的操做极可能致使咱们当前的goroutine阻塞，而咱们以后的操做都进行不了。而若是咱们又须要在当前channel阻塞进行其余操做，如操做其余channel或直接跳过阻塞，能够经过select来达到多个channel（可同时接受和发送）复用。以下面咱们的程序须要同时监听多个频道的信息：

broadcaster1 := make(chan string) // 频道1
broadcaster2 := make(chan string) // 频道2
select {
    case mess1 := <-broadcaster1:
        fmt.Println("来自频道1的消息：" + mess1)
    case mess2 := <-broadcaster2:
        fmt.Println("来自频道2的消息：" + mess2)
    default:
        fmt.Println("暂时没有任何频道的消息，请稍后再来~")
        time.Sleep(2 * time.Second)
}

select和switch语句有点类似，找到匹配的case执行对应的语句块，可是若是有两个或以上匹配的case语句，那么则会随机选择一个执行，若是都不匹配就会执行default语句块（若是含有default的部分的话）。
值得注意的是，select通常配合for循环来达到不断轮询管道的效果，可能不少小伙伴想着写个在某个case里用break来跳出for循环，这是不行的，由于break只会退出当前case，须要使用return来跳出函数或者弄个标志位标记退出

var flag = 0
for {
    if flag == 1 {break}
    select {
        case message := <- user.RecMess :
            event := gjson.Get(string(message), "event").String()
            if event == "login" {
                Login(message, user)
            }
            break
        case <- user.End :
            flag = 1
            break
    }
}

关闭

channel能够接受和发送数据，也能够被关闭。

close(ch)

关闭channel后，全部向channel发送数据的操做都会引发panic，而被close以后的channel仍然能够接受以前已经发送成功的channel数据，若是数据所有接受完毕，那么再从channel里面接受数据只会接收到零值得数据。

channel的关闭能够用来操做其余goroutine退出，在运行机制方面，goroutine只有在自身所在函数运行完毕，或者主函数运行完毕才会打断，因此咱们能够利用channel的关闭做为程序运行入口的一个标志位，若是channel关闭则中止运行。

没法直接让一个goroutine直接中止另外一个goroutine，但可使用通讯的方法让一个goroutine中止另外一个goroutine，以下例子就是程序一边运行，一边监听用户的输入，若是用户回车，则退出程序。

func main() {
    shutdown := make(chan struct{})
    var n sync.WaitGroup
    n.Add(1)
    go Running(shutdown, &n) 
    n.Add(1)
    go ListenStop(shutdown, &n) 
    n.Wait()
}

func Running(shutdown <-chan struct{}, n *sync.WaitGroup) {
    defer n.Done()
    for {
        select {
        case <-shutdown:
            // 一旦关闭channel，则能够接收到nil。
            fmt.Println("shutdown goroutine")
            return
        default:
            fmt.Println("I am running")
            time.Sleep(1 * time.Second)
        }   
    }   
}

func ListenStop(shutdown chan<- struct{}, n *sync.WaitGroup) {
    defer n.Done()
    os.Stdin.Read(make([]byte, 1)) 
    // 若是用户输入了回车则退出关闭channel
    close(shutdown)
}

利用channel关闭时候的传送的零值信号能够有效地退出其余goroutine，特别是关闭多个goroutine的时候，就不须要向channel传输多个信息了。