当一个资源需要在 goroutine 之间共享时，通道在 goroutine 之间架起了一个管道，并提供了确保同步交换数据的机制。（这是除了 atomic 和 mutex 之外的第三种处理竞态资源的方式）

Channel分为两种：

• 无缓冲的 Channel：无缓冲的通道(unbuffered channel)是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。如果两个 goroutine 没有同时准备好，通道会导致先执行发送或接收操作的 goroutine 阻塞等待。这种对通道进行发送和接收的交互行为本身就是同步的。
• 有缓冲的 Channel：有缓冲的通道(buffered channel)是一种在被接收前能存储一个或者多个值的通道。这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

一、无缓冲的 Channel 使用示例

import (
    "sync"
    "fmt"
    "math/rand"
)

var wg sync.WaitGroup

// Channel 完整的类型是 "chan 数据类型"
func player(name string, court chan int) {
    defer wg.Done()

    for {
        // 1. 阻塞等待接球，如果通道关闭，ok返回false
        ball, ok := <-court
        if !ok {
            fmt.Printf("channel already closed! Player %s won\n", name)
            return
        }

        random := rand.Intn(100)
        if random%13 == 0 {
            fmt.Printf("Player %s Lose\n", name)
            // 关闭通道
            close(court)
            return
        }

        fmt.Printf("Player %s Hit %d\n", name, ball)
        ball ++
        // 2. 发球，阻塞等待对方接球
        court <- ball
    }
}

// 两个 player 打网球，即生产者和消费者模式（互为生产者和消费者）
func main() {
    wg.Add(2)

    // 1. 创建一个无缓冲的通道
    // Channel 完整的类型是 "chan 数据类型"
    court := make(chan int)

    // 2. 创建两个 goroutine
    go player("zhangsan", court)
    go player("lisi", court)

    // 3. 发球：向通道发送数据，阻塞等待通道对端接收
    court <- 1

    // 4. 等待输家出现
    wg.Wait()
}

二、有缓冲的 Channel 使用示例

import (
    "sync"
    "fmt"
    "time"
)

// 使用4个goroutine来完成10个任务
const (
    taskNum      = 10
    goroutineNum = 4
)

var countDownLatch sync.WaitGroup

func worker(name string, taskChannel chan string) {
    defer countDownLatch.Done()
    for {
        // 1. 不断的阻塞等待分配工作
        task, ok := <-taskChannel
        if !ok {
            fmt.Printf("channel closed and channel is empty\n")
            return
        }

        //fmt.Printf("worker %s start %s\n", name, task)
        time.Sleep(100 * time.Millisecond)
        fmt.Printf("worker %s complete %s\n", name, task)
    }
}

func main() {
    countDownLatch.Add(goroutineNum)
    // 1. 创建有缓冲区的string channel
    taskChannel := make(chan string, taskNum)

    // 2. 创建 4 个goroutine去干活
    for i := 0; i < goroutineNum; i++ {
        go worker(fmt.Sprintf("worker %d", i), taskChannel)
    }

    // 3. 向通道加入task
    for i := 0; i < taskNum; i++ {
        taskChannel <- fmt.Sprintf("task %d", i)
    }

    // 4. 关闭通道：
    // 当通道关闭后，goroutine 依旧可以从通道接收数据，但是不能再向通道里发送数据。
    // 能够从已经关闭的通道接收数据这一点非常重要，因为这允许通道关闭后依旧能取出其中缓冲的全部值，而不会有数据丢失。
    // 从一个已经关闭且没有数据的通道里获取数据，总会立刻返回，并返回一个通道类型的零值
    close(taskChannel)

    // 5. 等待
    countDownLatch.Wait()
}

• 当通道关闭后，goroutine 依旧可以从通道接收数据，但是不能再向通道里发送数据。能够从已经关闭的通道接收数据这一点非常重要，因为这允许通道关闭后依旧能取出其中缓冲的全部值，而不会有数据丢失。
• 从一个已经关闭且没有数据的通道里获取数据，总会立刻返回，并返回一个通道类型的零值