date: 2018-6-10 15:14:50
title: go| go channel讲解 1
description: 应慕课网内容分享邀请, 试录 go channel 讲解主题的分享视频

很荣幸收到 慕课网 内容分享邀请, 试录 go channel 讲解主题的视频, 定位在 初级+基础, 希望帮助大家快速入门 go, 熟悉 go channel 的使用.

分享大纲:

• go 开发环境配置
• go channel 讲解: 为什么会有 go 和 channel, channel 编程上的细节
• 提升篇: 如何开始开发一个大型 go 项目; 深入理解协程之「快」

go 开发环境配置

• 安装
• 配置环境变量

环境变量 是非常常见的一个术语, 也是很多基础不太好的同学, 不太理解的一个概念. 要理解它其实很简单:

进程皆有环境 — 理解UNIX进程

程序运行之后, 在操作系统里面就是进程了, 而进程都有自己的环境, 环境变量属于环境的一种, 是进程可以访问到的资源.
其中非常常用的, 是 PATH 变量, 进程通过这个变量来寻找可执行文件. 如果没有这个变量的话, 就需要使用可执行文件的完整路径了.
比如 go.exe 可执行文件, 完整路径是 c:/tools/go/go.exe, 把 c:/tools/go 加入到 PATH 环境变量里, 才可以直接执行 go run 等命令, 否则就需要使用 c:/tools/go/go run.

起步阶段, 先只需要配置 GOROOT 和 GOPATH 2 个环境变量.

在 window 下配置环境变量有更快捷的操作: 使用 win+r 快捷键打开 运行窗口 输入 sysdm.cpl, 就可以快速打开环境变量的设置界面.

• hello go

环境配置好后, 就可以还是 hello world 之旅啦. 推荐 2 款工具: vscode goland.

vscode: hello go

vscode 会自动监测代码文件使用的语言, 提示安装相应的插件, 按照提示安装即可. 推荐安装 code runner 插件, 安装后使用 ctrl+alt+n 就可以快速运行当前文件

goland: hello go

goland 非常推荐, 强大的代码提示和很多带来效率提升的功能, 推荐使用 view | distraction free mode, 代码 清爽 的编码体验

go channel 讲解

• hello.go: hello world

package main

import (
    "fmt"
)

func main() {
    fmt.Println("hello czl")
}

使用 go run hello.go 运行

为什么使用协程

天下武功, 唯快不破

为了体验协程之快, 需要在 hello.go 做一点改造, 模拟一件耗时的任务, 这样方便比较

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("hello czl")

    // 普通版
    doSomeThing()
    // 协程版
    go doSomeThing()
}

// 模拟一件耗时的任务
func doSomeThing() {
    time.Sleep(time.Second*1)
}

只用添加 go 关键词, 就可以将任务抛给协程来执行, 是不是 hin 简单

使用 time go run hello.go 分别来比较, 会发现, 协程版快很多 呀

不过如果细心的话, 就会发现这个 快得有问题 — 耗时任务明明需要 1s, 怎么协程版居然 1s 内完成了?
改造一下模拟任务的函数, 就可以发现了:

// 模拟一件耗时的任务
func doSomeThing() {
    time.Sleep(time.Second*1)
    // 增加输出, 方便查看程序的执行效果
    fmt.Println("do some thing")
}

这就是 go 程序运行机制导致的 陷阱 — go程序运行时, 会依次寻找 package main -> func main(), 依次执行 main() 中代码,
当使用 go 关键字把任务交给协程执行后, 程序继续向下执行, 然而下面并没有其他需要执行的代码了, 所以 main() 就退出了, 并没有等待协程执行完.

问题来了: 怎么让我们程序里的协程执行完呢?

这里有三种方式:

• 方式一, 使用 sleep, 等协程执行完, 但是就不好比较协程版和非协程版的耗时了

// 方式一: sleep
go doSomeThing()
time.Sleep(time.Second*4)

• 方式二: 使用 channel, 通过读写 channel 触发协程等待

    // 方式二: channel
    ch := make(chan bool)
    go func() {
        doSomeThing()
        // 任务执行完了才给 channel 写数据
        ch <- true
    }()
    // 要等待 channel 里有数据
    <- ch

也正是 channel 的这一特性, 在后面 channel功能二: 协程调度 中会更详细的讲解

• 方式三: 调用 sync 系统库里的 WaitGroup API 实现

官方的定义如下:

A WaitGroup waits for a collection of goroutines to finish.
The main goroutine calls Add to set the number of goroutines to wait for.
Then each of the goroutines runs and calls Done when finished.
At the same time, Wait can be used to block until all goroutines have finished

用代码翻译过来, 是四步:

    // 方式三: WaitGroup
    var wg sync.WaitGroup // 第一步: 声明 WaitGroup
    wg.Add(1) // 第二步: 添加需要等待的协程, 需要等多少个协程, 就添加多少
    go func() {
        // 执行完之后需要做的操作
        defer wg.Done() // 第三步: 协程调用 done() 表示协程执行完了

        // 正常需要执行的逻辑
        doSomeThing()
    }()
    wg.Wait() // 第四步: 什么地方需要等待协程执行完, 就在上面地方加上 wait()

这里使用 go 中的 defer 关键字, defer 关键字可以在函数执行完后执行.
为什么要在函数一开始调用却在函数最后执行呢? 比如函数一开始打开了一个文件, 最后写了很多逻辑, 忘了关闭文件了, 使用 defer 就可以很好的避免这种情况.

准备工作, 或者说 热身 时间有点长, 来看看协程有多快, 多执行一点任务:

    // 快在哪? 多来点任务不就知道了
    for i := 0; i < 4; i++ {
        doSomeThing()
    }

    // 协程版
    var wg sync.WaitGroup
    wg.Add(4)
    for i := 0; i < 4; i++ {
        // wg.Add(1)
        go func() {
            defer wg.Done()

            doSomeThing()
        }()
    }
    wg.Wait()

使用 time go run hello.go, 会发现协程版要快很多. 可以把 for 循环再调多点, 感受就更明显了

> 23:47 src $ time go run hello.go
hello world
do some thing
do some thing
do some thing
do some thing

real    0m4.978s
user    0m0.000s
sys     0m0.015s

> 00:23 src $ time go run hello.go
hello world
do some thing
do some thing
do some thing
do some thing

real    0m2.200s
user    0m0.000s
sys     0m0.031s

写在后面

感受到 协程之快 以及 需要多个协程来执行任务 后, 就引入了下一个话题:

为什么要使用 channel? — 因为有多个协程.