目录

• channel 介绍
• channel创建
• channel 操作符与Range
• channel读写与关闭
• channel类型-有缓存与无缓存
• channel阻塞
• 例1：channel定义
• 例2：缓冲区channel定义
• 例3：channel通知结束-通过通信来共享内存
• 例4：channel用在goroutine之间的同步
• 例5：channel等待结束结束-sync.WaitGroup

channel 介绍

channel 提供了一种通信机制，通过它，一个 goroutine 可以想另一 goroutine 发送消息。channel 本身还需关联了一个类型，也就是 channel 可以发送数据的类型。例如: 发送 int 类型消息的 channel 写作 chan int 。

channel 是 goroutine 之间通信的一种方式，可以类比成 Unix 中的进程的通信方式管道。

channel创建

和 map 和 slice 数据类型一样channel必须先创建再使用。

ch := make(chan int)

c和 map 类似，make 创建了一个底层数据结构的引用，当赋值或参数传递时，只是拷贝了一个 channel 引用，指向相同的 channel 对象。和其他引用类型一样，channel 的空值为 nil 。使用 == 可以对类型相同的 channel 进行比较，只有指向相同对象或同为 nil 时，才返回 true。

channel操作符与range(遍历）

操作符

它的操作符是箭头 <-，其中(箭头的指向就是数据的流向。

ch <- v    // 发送值v到Channel ch中
v := <-ch  // 从Channel ch中接收数据，并将数据赋值给v

Range(遍历)：for …… range语句可以处理Channel。

func main() {
    go func() {
        time.Sleep(1 * time.Hour)
    }()
    c := make(chan int)
    go func() {
        for i := 0; i < 10; i = i + 1 {
            c <- i
        }
        close(c)
    }()
    for i := range c {
        fmt.Println(i)
    }
    fmt.Println("Finished")
}

channel读、写与关闭

向channel写(发送)数据

// 向channel中发送(写)数据。
ch <- x //send

从channel读(接收)数据

//receive:从 channel 中取(读) 出数据, ok用于判断channel是否关闭
x, ok := <- ch 
//或
x = <- ch

channel关闭

close(chan变量)

与关闭相关的注意以下事项:

• 关闭一个未初始化(nil) 的 channel 会产生 panic
• 重复关闭同一个 channel 会产生 panic
• 向一个已关闭的 channel 中发送消息会产生 panic
• 从已关闭的 channel 读取消息不会产生 panic，且能读出 channel 中还未被读取的消息，若消息均已读出，则会读到类型的零值。从一个已关闭的 channel 中读取消息永远不会阻塞，并且会返回一个为 false 的 ok-idiom，可以用它来判断 channel 是否关闭
• 关闭 channel 会产生一个广播机制，所有向 channel 读取消息的 goroutine 都会收到消息

channel类型

channel 分为不带缓存的 channel 和带缓存的 channel。

无缓存的 channel

从无缓存的 channel 中读取消息会阻塞，直到有 goroutine 向该 channel 中发送消息；同理，向无缓存的 channel 中发送消息也会阻塞，直到有 goroutine 从 channel 中读取消息。

通过无缓存的 channel 进行通信时，接收者收到数据 happens before 发送者 goroutine 唤醒。

有缓存的 channel

有缓存的 channel 的声明方式为指定 make 函数的第二个参数，该参数为 channel 缓存的容量

ch := make(chan int, 10)

有缓存的 channel 类似一个阻塞队列(采用环形数组实现)。当缓存未满时，向 channel 中发送消息时不会阻塞，当缓存满时，发送操作将被阻塞，直到有其他 goroutine 从中读取消息；相应的，当 channel 中消息不为空时，读取消息不会出现阻塞，当 channel 为空时，读取操作会造成阻塞，直到有 goroutine 向 channel 中写入消息。

ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3

// blocked, send to full buffered channel
ch <- 4

通过 len 函数可以获得 chan 中的元素个数，通过 cap 函数可以得到 channel 的缓存长度。

blocking

默认情况下，发送和接收会一直阻塞着，直到另一方准备好。
这种方式可以用来在gororutine中进行数据同步，而不必使用显示的锁或者条件变量。

import "fmt"
func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // send sum to c
}
func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    // receive from c
    //x, y := <-c, <-c这句会一直等待计算结果发送到channel中
    x, y := <-c, <-c 
    fmt.Println(x, y, x+y)
}

综合实例

例1：channel定义

/**
 * chan <- string:<- 代表发数据
 * <- chan int: 代表收数据
 */
func createWorker(id int)  chan int {
    c := make(chan int)
    for {
        fmt.Printf("worker %d receiver %d \n", id, n)
    }
    return c
}

func main()  {
    var channels [10]chan int
    for i :=0; i<10 ; i++{
        channels[i] = createWorker(i)
    }
    //worker只有有输入channel时，才打有数据打印输出
    //1.分发数据
    for i :=0; i<10 ; i++{
        //string('a' + i) : a会因为i而变为b,c,d,f..
        channels[i] <- 'a' + i
    }

    for i :=0; i<10 ; i++{
        //<- 发送数据的意思
        channels[i] <- 'A' + i
    }
    time.Sleep(time.Microsecond)
}

例2：缓冲区channel定义

package main

import (
    "fmt"
    "time"
)

func write(ch chan int){
    for i := 0; i < 100; i++ {
        ch <- i
    }
}

func read(ch chan int){
    for {
        b,ok := <- ch
        if ok == false {
            fmt.Println("chan is close")
            break
        }
        fmt.Println(b)
    }
}

func main(){
    intChan := make(chan int, 10)
    go write(intChan)
    go read(intChan)
    time.Sleep(10*time.Second)
}

例3：channel通知结束-通过通信来共享内存

package main

import (
    "fmt"
)

type worker struct {
    in chan  int


    done chan bool
}
/**

 */
func  doWorker(id int,c chan int,done chan  bool)  {
    for n := range c {  //待到c 被close时,退出
        fmt.Printf("worker %d receiver %d \n", id, n)
        //done <- true //必须有人收，否则会 fatal error: all goroutines are asleep - deadlock!
        //修改如下
        go func() {done <- true}()
    }
}
/**
 * chan <- string:<- 代表发数据
 * <- chan int: 代表收数据
 */
func createWorker(id int) worker {
    w := worker{
        in: make(chan int),
        done: make(chan bool),
    }
    //处理
    go doWorker(id,w.in,w.done)
    return w
}


//func closeChannel(w worker)  {
//  close(w.in)
//  w.done <- false
//}

func channelDemo()  {
    var workers [10]worker
    for i :=0; i<10 ; i++{
        workers[i] = createWorker(i)
    }


    //worker只有有输入channel时，才打有数据打印输出
    //1.发数据
    for i ,_:= range workers {
        workers[i].in <- 'a' + i
    }

    //发数据
    for i ,_:= range workers {
        //<- 发送数据的意思
        workers[i].in <- 'A' + i
    }

    for _,worker := range workers{
        <- worker.done
        <- worker.done
    }

}

func main() {
    channelDemo()
    //time.Sleep(time.Microsecond)
    //bufferChannel()
    //channelClose()
}

例4：channel用在goroutine之间的同步

channel可以用在goroutine之间的同步。worker做完任务后只需往channel发送一个数据就可以通知main goroutine任务完成。

import (
    "fmt"
    "time"
)
func worker(done chan bool) {
    time.Sleep(time.Second)
    // 通知任务已完成
    done <- true
}
func main() {
    done := make(chan bool, 1)
    go worker(done)
    // 等待任务完成
    <-done
}

例4：channel等待结束结束-sync.WaitGroup

package main

import (
    "fmt"
    "sync"
)

type worker struct {
    in chan  int
    wg *sync.WaitGroup
}
/**
sync.WaitGroup方法：

var wg sync.WaitGroup
wg.add
wg.done
wg.wait
 */
func  doWorker(id int,c chan int,wg *sync.WaitGroup)  {
    for n := range c {  //待到c 被close时,退出
        fmt.Printf("worker %d receiver %d \n", id, n)
        wg.Done()
    }
}

func createWorker(id int,wg *sync.WaitGroup) worker {
    w := worker{
        in: make(chan int),
        wg: wg,
    }
    //处理
    go doWorker(id,w.in,wg)
    return w
}


func channelDemo()  {
    var wg sync.WaitGroup
    var workers [10]worker
    for i :=0; i<10 ; i++{
        //只是传递地址给到createWoker
        workers[i] = createWorker(i,&wg)
    }

    //增加20个任务等待结束
    wg.Add(20)
    //1.发数据
    for i ,_:= range workers {
        workers[i].in <- 'a' + i
        //或者 循环内: wg.Add(1)
    }

    //发数据: <-
    for i ,_:= range workers {
        workers[i].in <- 'A' + i
    }

    wg.Wait()
}

func main() {
    channelDemo()
}

例5： 收发数据

package main

import (
    "fmt"
    "time"
)

/**
 * chan <- string:<- 代表发数据
 * <- chan int: 代表收数据
 */
func createWorker(id int,c chan string)  chan string {
    for {
        fmt.Printf("worker %d receiver %s \n",id, <- c)
    }
    return c
}

func channelDemo()  {
    var channels [10]chan string
    for i :=0; i<10 ; i++{
        channels[i] = make(chan string)
        go createWorker(i,channels[i])
    }

    //worker只有有输入channel时，才打有数据打印输出

    //1.分发数据
    for i :=0; i<10 ; i++{
        //string('a' + i) : a会因为i而变为b,c,d,f..
        channels[i] <- string('a' + i)
    }

    for i :=0; i<10 ; i++{
        //<- 发送数据的意思
        channels[i] <- string('A' + i)
    }
    time.Sleep(time.Microsecond)

}

func main() {
    channelDemo()
    time.Sleep(time.Microsecond)

}