前言

这是我学习Go语法的笔记。由于有C和Python的基础，上手Go很快。笔记很粗糙，好在自己够用。

此篇包括了Go相关的：并发编程，信号通道，定时器等。涉及关键字go select。

goroutine

Go天生优秀，利用关键字go可以很容易的实现并发编程。如一个并发示例：

func print_a() {
    for {
        fmt.Println("a")
        time.Sleep(time.Second)  // 睡1s
    }
}

func print_b() {
    for {
        fmt.Println("b")
        time.Sleep(time.Second)  // // 睡1s
    }
}

func main() {
    go print_a()  // 打印 a
    go  print_b()  // 打印 b

    fmt.Println("等待线程执行")
    for {  // 死循环
    }
}

运行上述代码，可看到程序交替打印ab。如果不出意外，程序会先打印“等待线程执行”，然后打印ab。所需注意两点：

以go方式调用的函数都是异步执行的。也就是说，不会等到被调函数返回结果才往下执行；
主协程退出，它的子协程跟着退出。因此上述demo中设置死循环，是为避免程序退出，导致两个协程跟着退出。

runtime

以下简单介绍runtime包的使用，其中包括了Gosched，Goexit和GOMAXPROCS。

Gosched

Gosched表示让出时间片，可以让本应该执行的协程稍后执行。

func main() {
    go func() {
        fmt.Println("this is a")
    }()

    fmt.Println("this is b")
}
// 输出：
this is b

上述代码中匿名函数的功能是打印语句“this is a”，以协程的方式执行。然而，在子协程开始之前，主协程已经往下执行并执行结束，所以demo的运行结果是：只打印了“this is b”。马上来试试Gosched的效果：

func main() {
    go func() {
        fmt.Println("this is a")
    }()
    
    runtime.Gosched()
    fmt.Println("this is b")
}
// 输出：
this is a
this is b

现在demo的执行结果是先打印a然后打印b。这是因为程序遇到runtime.Gosched()后会主动让出执行权，此时子协程也排队等着了，一看到“有空位”就立马钻进去执行，才有了我们看到的结果。

Goexit

Goexit能够终止一个正在执行的协程，其作用效果跟return类似。有一点需要额外注意：Goexit不能在主函数中使用，否则程序panic。子协程退出时，依然能够执行defer修饰的语句。

func test() {
    defer fmt.Println("three")
    runtime.Goexit()  // 等同return
    fmt.Println("four")  // 这句话不会被执行
}

func main() {
    fmt.Println("one")
    go test()
    fmt.Println("two")

    for{
    }
}
// 输出：
one
two
three

GOMAXPROCS

Go语言默认单核运行，通过runtime.GOMAXPROCS()设置参与运行的CPU个数。runtime.NumCPU()用来获取计算机CPU数。查阅网上部分资料，发现有人说设置最大CPU数最好不要超过实际CPU数，但也有人说在一定范围内超过效果最佳。这里存疑。

func main() {
    ...
    runtime.GOMAXPROCS(2)  // 设置最大2核处理，函数返回计算机实际最大核数
    ...
}

channel

goroutine运行在相同的地址空间上，因此访问内存必须做好同步。goroutine通过通信共享内存，而不是共享内存来通信。在函数传递中，channel引用传递。不同角度可对channel做不同分类：

第一种可以是：有缓存channel和无缓存channel；
第二种可以是：单向channel和双向channel。

无缓存与有缓存

创建channel：

make(chan Type)  // 无缓存，等价于make(chan Type, 0)
make(chan Type, capacity)  // 有缓存

当capacity=0时，channel无缓冲阻塞读写；当capacity>0时，channel有缓冲非阻塞，直到写满capacity个元素才阻塞写入。channel通过操作符<-接收、发送数据。如ch<-表示发出数据到ch中，<-ch表示从ch中接收数据。常用操作如下：

channel<- value  // 发送value到channel
<-channel  // 接收并丢弃
x := <-channel  // 从channel中接收数据，并赋值给x
x, ok := <-channel  // 功能同上，同时检查通道是否已关闭或者是否为空

无缓存与有缓存的示例对比：

var ch = make(chan int)

func producer() {
    for {
        randomNum := rand.Intn(100)  // 生产随机数
        ch<- randomNum  // 发送channel中
        fmt.Println("生产一个数据为：", randomNum)
    }
}

func comsumer() {
    for {
        data := <-ch  // 从channel中接收数据
        fmt.Println("处理一个数据为：",  data)
    }
}

func main() {
    go producer()
    go comsumer()
    for{
    }
}

运行上述代码，总能看到生产者与消费者成对出现。这正是由于无缓冲channel在接收一个数据后会立马阻塞协程，等到消费者从channel中拿走数据再继续向下执行。

// 输出：
...
处理一个数据为： 14
生产一个数据为： 14
生产一个数据为： 16
处理一个数据为： 16
处理一个数据为： 23
生产一个数据为： 23
生产一个数据为： 57
处理一个数据为： 57
...

现将channel修改为有缓冲，缓冲为10。即：var ch = make(chan int， 10)，观察运行结果：

...
处理一个数据为： 45
处理一个数据为： 23
处理一个数据为： 44
生产一个数据为： 5
生产一个数据为： 30
生产一个数据为： 34
处理一个数据为： 86
...

生产者与消费者没有成对出现。因为channel“满载”前，程序不会被阻塞。

len(ch) 缓冲区数据个数； cap(ch)缓冲区大小。

单向channel

前面提到的channel都是双向的，既可写也可读。Go允许做一个单向channel，其职责是：要么写、要么读。这有利于程序员对程序的控制，以及程序出错时方便排查。

单向channel是由双向channel隐式转换来的：

ch := make(chan int)

var onlyWrite chan<- int = ch  // 只写不读
var onlyRead <-chan int = ch  // 只读不写

然而单向不能转双向。这种用法更多是在函数传参时使用，场景为消费者与生产者：

func provider(ch chan<-int) {
    ...
}

func comsumer(ch <-chan int) {
    ...
}

func main() {
    ch := make(chan int)
    go provider(ch)
    go comsumer(ch)
    ...
}

关闭channel

可利用close()关闭channel，关闭后，不可以再向channel发送数据（会引发panic），但可以从channel中读取之前已有的数据。

检查channel是否关闭可以：

if num, ok := <-ch; ok == true {
    ...
}

可利用range对channel遍历：

func get_data(onlyRead <-chan int) {
    for value := range onlyRead {
        fmt.Println(value)
    }
}

func main() {
    ch := make(chan int, 0)
    
    go get_data(ch)
    for i:=0; i<10; i++ {
        ch<- i
    }

定时器

定时器分Timer与Ticker，前者会在指定的时间上作用一下，后者则是循环作用。

Timer

简单示例：

func main() {
    fmt.Println("当前时间", time.Now())  // 打印当前时间
    timer := time.NewTimer(2 * time.Second)  // 创建一个timer，设置为2s后往timer.C管道中写数据
                                             // 写的数据是，这一刻的时间
    fmt.Println("程序继续向下执行")

    fmt.Println("程序被阻塞...")
    fmt.Println("管道中的内容：", <-timer.C)  // 程序在此阻塞，直到管道中有数据了，取出数据
    fmt.Println("当前时间", time.Now())  // 打印当前时间
}
// 输出：
当前时间 2019-03-02 10:44:46.4775098 +0800 CST m=+0.013954001
程序继续向下执行
程序被阻塞...
管道中的内容： 2019-03-02 10:44:48.5120856 +0800 CST m=+2.048529801
当前时间 2019-03-02 10:44:48.5120856 +0800 CST m=+2.048529801

time包的一些其他用法：

After：

time.After(2* time.Second)  // 定时2s，2s后向管道写入内容
// 由于该函数会返回一个管道类型的数据，因此可以直接对它做读操作
// eg: `<-time.After(2* time.Second)`  这种用法会把程序阻塞，类似time.Sleep()

Stop：

timer := time.NewTimer(2 * time.Second)
timer.Stop()  // 停止定时器，若在停止前定时器没有写入数据，以后也不会写入了

Reset：

fmt.Println("当前时间：", time.Now())
timer := time.NewTimer(10 * time.Second)  // 10s后写入数据
timer.Reset(time.Second)  // 重置时间，指定1s后写入数据
fmt.Println("输出内容：", <-timer.C)

// 输出：
当前时间： 2019-03-02 11:10:26.3631141 +0800 CST m=+0.014000901
输出内容： 2019-03-02 11:10:27.3977497 +0800 CST m=+1.048636501

Ticker

func main() {
    ticker := time.NewTicker(1 * time.Second)
    for {
        fmt.Println(<-ticker.C)
    }
}
// 输出：
2019-03-02 12:50:32.005107 +0800 CST m=+1.011311801
2019-03-02 12:50:33.0049539 +0800 CST m=+2.011158701
2019-03-02 12:50:34.0057679 +0800 CST m=+3.011972701
2019-03-02 12:50:35.0052581 +0800 CST m=+4.011462901
2019-03-02 12:50:36.0057503 +0800 CST m=+5.011955101
...

select

select是Go中的关键字，用于监听IO操作，当IO操作发生时，触发对应的动作。select的使用与switch相似，区别在于，select中的case必须是IO操作。

...
func main() {
    var (
        chApha =  make(chan string)
        chNum = make(chan int)
    )
    ...
    select {
    case <-chApha:  // 如果`<-chApha`可以先执行，就打印"处理一个字母"
        fmt.Println("处理一个字母")
    case <-chNum:  // 如果`<-chNum`可以先执行，就打印"处理一个数字"
        fmt.Println("处理一个数字")
    default:  // 如果前面都不能执行，就打印"等不到"
        fmt.Println("等不到了")
    }
}

说明：在select中使用default，属于少数情况。

有关心情

Guan