golang中channel的用法

channel 有点类似于管道，它在 goroutine 同步与通信中，有着起承转合的作用，同时也是 Golang 实现 CSP 模型的关键

package main

func main() {
    senderOnly := make(chan<- int)   // 只能用来发送（管道的入口，只进不出）
    receiverOnly := make(<-chan int) // 只能用来接收（管道的出口，只出不进）
    unbuffer := make(chan int)       // 无缓冲可收发
    buffer := make(chan int, 2)      // 无缓冲可收发
    println(senderOnly, receiverOnly, unbuffer, buffer)
}

以下是 channel 的一些使用场景

等待goroutine完成

package main

func main() {
    println("start main")
    ch := make(chan bool)
    go func() {
        println("come into goroutine")
        ch <- true
    }()

    println("do something else")
    <-ch
    close(ch)

    println("end main")
}

在playground中运行

打印结果：

start main
do something else
come into goroutine
end main

多个goroutine协同

三个功能不相关的 goroutine 最后结果要汇总累加到 result 上

package main

func main() {
    println("start main")
    ch := make(chan int)

    var result int
    go func() {
        println("come into goroutine1")
        var r int
        for i := 1; i <= 10; i++ {
            r += i
        }
        ch <- r
    }()

    go func() {
        println("come into goroutine2")
        var r int = 1
        for i := 1; i <= 10; i++ {
            r *= i
        }
        ch <- r
    }()

    go func() {
        println("come into goroutine3")
        ch <- 11
    }()

    for i := 0; i < 3; i++ {
        result += <-ch
    }
    close(ch)
    println("result is:", result)
    println("end main")
}

在playground中运行

其中一组打印结果：

start main
come into goroutine3
come into goroutine2
come into goroutine1
result is: 3628866
end main

Select

两个 goroutine 无直接关联，但其中一个先达到某一设定条件便退出或超时退出

package main

import "time"

func main() {
    println("start main")
    cond1 := make(chan int)
    cond2 := make(chan uint64)

    go func() {
        for i := 0; ; i++ {
            cond1 <- i
        }
    }()

    go func() {
        var i uint64
        for ; ; i++ {
            cond2 <- i
        }
    }()

    endCond := false
    for endCond != true {
        select {
        case a := <-cond1:
            if a > 99 {
                println("end with cond1")
                endCond = true
            }
        case b := <-cond2:
            if b == 100 {
                println("end with cond2")
                endCond = true
            }
        case <-time.After(time.Microsecond):
            println("end with timeout")
            endCond = true
        }
    }

    println("end main")
}

在playground中运行

其中打印结果有可能是：

start main
end with cond1
end main

也有可能是：

start main
end with timeout
end main

也可能是:

start main
end with cond2
end main

这说明循环100次大概需要1微秒的时间

channel与range

package main

import "fmt"

func main() {
    println("start main")
    ch := make(chan int, 4)
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        // 如果不关闭channel,会引发panic
        close(ch)
    }()

    for v := range ch {
        fmt.Println(v)
    }
    println("end main")
}

打印结果为：

start main
0
1
2
3
4
5
6
7
8
9
end main

无缓冲 channel

package main

func main() {
    var ch = make(chan int)
    ch <- 1
    println(<-ch)
}

在playground中运行

打印结果为：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
    /tmp/sandbox117018544/main.go:5 +0x60

死锁了，为什么会这样呢，因为 ch 是一个无缓冲的 channel ,在执行到 ch <- 1 就阻塞了当前 goroutine （也就是main函数所在的 goroutine ）,后面打印语句根本没机会执行

package main

func main() {
    var ch = make(chan int)
    go func() {
        ch <- 1
        println("sender")
    }()
    println(<-ch)
}

因为此时 ch 既有发送也有接收而且不在同一个 goroutine 里面，此时它们不会相互阻塞