《Go语言入门经典》10~12章读书笔记

第10章处理错误

10.1 错误处理及Go语言的独特之处

在Go语言中，一种约定是在调用可能出现问题的方法或函数时，返回一个类型为错误的值。这意味着如果出现问题，函数通常不会引发异常，而让调用者决定如何处理错误。

package main

import (
    "fmt"
    "io/ioutil"
)


func main() {
    file, err := ioutil.ReadFile("foo.txt");
    if err != nil{
        fmt.Println(err)
        return
    }

    fmt.Printf("%s", file)
} 

在没有文件foo.txt的系统中运行这个程序时，将触发错误。

要理解Go语言处理错误的方式，最重要的是明白函数ReadFile接受一个字符串参数，并返回一个字节切片和一个错误值。这个函数的定义如下。

func ReadFile(filename string) ([]byte, error)

这意味着函数ReadFile总是会返回一个错误值，可对其进行检查。

在Go语言中，有一种约定是，如果没有发生错误，返回的错误值将为nil。
这让程序员调用方法或函数时，能够检查它是否像预期那样执行完毕。

10.2 理解错误类型

在Go语言中，错误是一个值。标准库声明了接口error，如下所示。

type error interface{
    Error() string
}

这个接口只有一个方法——Error，它返回一个字符串。

10.3 创建错误

标准库中的errors包支持创建和操作错误。下例演示了如何创建并打印错误。

package main

import (
    "fmt"
    "errors"
)


func main() {
    err := errors.New("Something wrong")
    if err != nil{
        fmt.Println(err)
    }
}

10.4 设置错误的格式

除errors包外，标准库中的fmt包还提供了方法Errorf，可用于设置返回的错误字符串的格式。

package main

import (
    "fmt"
)

func main() {
    name, role := "yuxi", "dancer"
    err := fmt.Errorf("%v %v", name, role)
    if err != nil {
        fmt.Println(err)
    }   
}

10.5 从函数返回错误

Go语言的做法是从函数和方法中返回一个错误值。下面是一个示例。

package main

import (
    "fmt"
)

func Half(num int)(int, error){
    if num % 2 != 0{
        return -1, fmt.Errorf("Cannot half %v", num)
    }

    return num / 2, nil
}

func main() {
    n, err := Half(9)
    if err != nil{
        fmt.Println(err)
        return
    }

    fmt.Println(n)
}

这个示例演示了Go语言错误处理方式的一个优点：错误处理不是在函数中，而是在调用函数的地方进行的。这在错误处理方面提供了极大的灵活性，而不是简单地一刀切。

10.6 错误和可用性

除从技术角度考虑Go语言的错误处理方式和错误生成方式外，还需从以用户为中心的角度考虑错误。编写供他人使用的库或包时，您编写和使用错误的方式将极大地影响可用性。

如果库用户相信错误会以一致的方式返回，且包含有用的错误消息，则用户能够从错误中恢复的可能性将高得多。他们很可能也会认为您编写的库不仅很有用，而且值得信任。

10.7 慎用panic

panic是Go语言中的一个内置函数，它终止正常的控制流程并引发恐慌（panicking），导致程序停止执行。出现普通错误时，并不提倡这种做法，因为程序将停止执行，并且没有任何回旋余地。

package main

import (
    "fmt"
)

func main() {
    fmt.Println("This is executed")
    panic("oh no. i can do no more")
    fmt.Println("This is not executed")
}

运行这个示例将引发panic，导致程序崩溃。

This is executed
panic: oh no. i can do no more

goroutine 1 [running]:
main.main()
        /home/go/panic.go:10 +0x79
exit status 2

调用panic后，程序将停止执行，因此打印This is not executed的代码行根本没有机会执行。

在下面的情形下，使用panic可能是正确的选择。

• 程序处于无法恢复的状态。这可能意味着无路可走了，或者再往下执行程序将带来更多的问题。在这种情况下，最佳的选择是让程序崩溃。
• 发生了无法处理的错误。

第11章使用Goroutine

11.1 理解并发

在最简单的计算机程序中，操作是依次执行的，执行顺序与出现顺序相同。

另一种理念是不必等到一个操作执行完毕后再执行下一个，编程任务和编程环境越复杂，这种理念就越重要。提出这种理念旨在让程序能够应对更复杂的情形，避免执行完一行代码后再执行下一行，从而提高程序的执行速度。

11.2 并发和并行

同时烤多个蛋挞被称为并发；而将烤蛋挞的任务分为两部分，由两家分别烤，烤好后再放在一起，这被称为并行。

11.5 使用Goroutine处理并发操作

Go语言提供了Goroutine，让您能够处理并发操作。下例中，通过使用Goroutine，可在调用函数slowFunc后立即执行main函数中的第二行代码。在这种情况下，函数slowFunc依然会执行，但不会阻塞程序中其他代码行的执行。Goroutine使用起来非常简单，只需在要让Goroutine执行的函数或方法前加上关键字go即可。

package main

import (
    "fmt"
    "time"
)

func slowFunc(){
    time.Sleep(time.Second * 2)
    fmt.Println("sleeper() finished")
}

func main() {
    go slowFunc()
    fmt.Println("i am now shown straightway")

    time.Sleep(time.Second * 3)
}

运行结果

i am now shown straightway
sleeper() finished

说明：

• go 使得slowFunc()不会阻塞下面的代码
• time.Sleep(time.Second * 3)是为了让main可以等到slowFunc执行完成，不然将无法看到sleeper() finished的输出。

11.6 定义Goroutine

Go在幕后使用线程来管理并发，但Goroutine让程序员无须直接管理线程，它消除了这样做的痛苦。创建一个Goroutine只需占用几KB的内存，因此即便创建数千个Goroutine也不会耗尽内存。另外，创建和销毁Goroutine的效率也非常高。

Goroutine是一个并发抽象，因此开发人员通常无须准确地知道操作系统中发生的情况。

第12章通道简介

12.1 使用通道

如果说Goroutine是一种支持并发编程的方式，那么通道就是一种与Goroutine通信的方式。通道让数据能够进入和离开Goroutine，可方便Goroutine之间进行通信。

通道的创建语法如下。

c := make(chan string)

• 使用简短变量赋值，将变量c初始化为:=右边的值。
• 使用内置函数make创建一个通道，这是使用关键字chan指定的。
• 关键字chan后面的string指出这个通道将用于存储字符串数据，这意味着这个通道只能用于收发字符串值。

向通道发送消息的语法如下。

c <- "hello"

请注意其中的<-，这表示将右边的字符串发送给左边的通道。如果通道被指定为收发字符串，则只能向它发送字符串消息，如果向它发送其他类型的消息将导致错误。

从通道那里接收消息的语法如下。

msg := <-c

现在可对程序清单11.5节中的代码进行修改以使用通道，如程序清单如下。

package main

import (
    "fmt"
    "time"
)

func slowFunc(c chan string){
    time.Sleep(time.Second * 2)
    c <- "showFunc() finished"
}

func main() {
    c := make(chan string)
    go slowFunc(c)

    fmt.Println("i am now shown straightway")
    
    msg := <-c
    fmt.Println(msg)
}

说明：

• 创建一个存储字符串数据的通道，并将其赋给变量c。
• 函数slowFunc将通道当作参数。
• slowFunc函数的单个参数指定了一个通道和一个字符串的数据类型。
• 声明变量msg，用于接收来自通道c的消息。这将阻塞进程直到收到消息为止，从而避免进程过早退出。
• 函数slowFunc执行完毕后向通道c发送一条消息。
• 接收并打印这条消息。
• 由于没有其他的语句，因此程序就此退出。

12.2 使用缓冲通道

通常，通道收到消息后就可将其发送给接收者，但有时候可能没有接收者。在这种情况下，可使用缓冲通道。缓冲意味着可将数据存储在通道中，等接收者准备就绪再交给它。要创建缓冲通道，可向内置函数make传递另一个表示缓冲区长度的参数。

message := make(chan string, 2)

这些代码创建一个可存储两条消息的缓冲通道。缓冲通道最多只能存储指定数量的消息，如果向它发送更多的消息将导致错误。

package main

import (
    "fmt"
)

func receiver(c chan string){
    for msg := range c{
        fmt.Println(msg)
    }
}

func main() {
    msg := make(chan string, 2)
    msg <- "hello"
    msg <- "world"
    
    close(msg)
    
    receiver(msg)
}

解读如下

• 创建一个长度为2的缓冲通道。
• 向通道发送两条消息。此时没有可用的接收者，因此消息被缓冲。
• 关闭通道（close），这意味着不能再向它发送消息。
• 将通道作为参数传递给函数receiver。
• 函数receiver使用range迭代通道，并将通道中缓冲的消息打印到控制台。

在知道需要启动多少个Goroutine或需要限制调度的工作量时，缓冲通道很有效。

12.3 阻塞和流程控制

给通道指定消息接收者是一个阻塞操作，因为它将阻止函数返回，直到收到一条消息为止。

package main

import (
    "fmt"
    "time"
)

func pinger(c chan string){
    t := time.NewTicker(1 * time.Second)
    for {
        c <- "ping"
        <-t.C
    }
}

func main() {
    msgs := make(chan string)
    
    go pinger(msgs)
    
    for {
       msg  := <-msgs
       fmt.Println(msg)
    }   
}

运行结果是每秒输出一个ping

说明：

• time.NewTicker每秒触发一次，效果和使用time.Sleep(time.Second * 1)一样。如果你用过js, 这两者可以分别类比为setInterval和setTimeout。

12.4 将通道用作函数参数

可将通道作为参数传递给函数，并在函数中向通道发送消息。要进一步指定在函数中如何使用传入的通道，可在传递通道时将其指定为只读、只写或读写的。指定通道是只读、只写、读写的语法差别不大。

func channelReader(messages <-chan string){
    msg := <-messages
    fmt.Println(msg)
}

func channelWriter(messages chan<- string){
    messages <- "Hello world"
}

func channelReaderAndWriter(messages chan string){
    msg := <-messages
    fmt.Println(msg)
    messages <- "Hello world"
}

<-位于关键字chan左边时，表示通道在函数内是只读的；<-位于关键字chan右边时，表示通道在函数内是只写的；没有指定<-时，表示通道是可读写的。

12.5 使用select语句

假设有多个Goroutine，而程序将根据最先返回的Goroutine执行相应的操作，此时可使用select语句。它为通道创建一系列接收者，并执行最先收到消息的接收者。

select语句看起来和switch语句很像。

    ch1 := make (chan string)
    ch2 := make (chan string)

    select{
        case msg1 := <- ch1:
            fmt.Println("recv msg1", msg1)
        case msg2 := <- ch2:
            fmt.Println("recv msg2", msg2)
    }
}

如果从通道ch1那里收到了消息，将执行第一条case语句；如果从通道ch2那里收到了消息，将执行第二条case语句。具体执行哪条case语句，取决于消息到达的时间，哪条消息最先到达决定了将执行哪条case语句。通常，接下来收到的其他消息将被丢弃。收到一条消息后，select语句将不再阻塞。

下面的程序演示了select语句

package main

import (
    "fmt"
    "time"
)

func ping1(c chan string){
    time.Sleep(time.Second * 1)
    c <- "ping on channel1"
}

func ping2(c chan string){
    time.Sleep(time.Second * 2)
    c <- "ping on channel2"
}

func main() {
    ch1 := make (chan string)
    ch2 := make (chan string)
    
    go ping1(ch1)
    go ping2(ch2)

    select{
        case msg1 := <- ch1:
            fmt.Println("recv msg1", msg1)
        case msg2 := <- ch2:
            fmt.Println("recv msg2", msg2)
    }
}

要根据最先收到的消息采取相应的措施，select语句是一个不错的选择。但如果没有收到消息呢？为此可使用超时时间。这让select语句在指定时间后不再阻塞，以便接着往下执行。

下面的程序添加了一个超时case语句，指定在0.5s内没有收到消息时将采取的措施。

select{
        case msg1 := <- ch1:
            fmt.Println("recv msg1", msg1)
        case msg2 := <- ch2:
            fmt.Println("recv msg2", msg2)
        case <-time.After(500 * time.Millisecond):
            fmt.Println("no msg recv. give up.")
}

12.6 退出通道

在已知需要停止执行的时间的情况下，使用超时时间是不错的选择，但在有些情况下，不确定select语句该在何时返回，因此不能使用定时器。在这种情况下，可使用退出通道。这种技术并非语言规范的组成部分，但可通过向通道发送消息来理解退出阻塞的select语句。

来看这样一种情形：程序需要使用select语句实现无限制地阻塞，但同时要求能够随时返回。通过在select语句中添加一个退出通道，可向退出通道发送消息来结束该语句，从而停止阻塞。可将退出通道视为阻塞式select语句的开关。对于退出通道，可随便命名，但通常将其命名为stop或quit。在下面的示例中，在for循环中使用了一条select语句，这意味着它将无限制地阻塞，并不断地接收消息。通过向通道stop发送消息，可让select语句停止阻塞：从for循环中返回，并继续往下执行。

    messages := make (chan string)
    stop := make(chan bool)

    for {
        select{
            case <-stop:
                return
            case msg := <- messages:
                fmt.Println(msg)
        }
    }

在应用程序的某部分向通道发送消息，并要在未来的某个位置时点终止时，这种技术是很有效的。

下面是一个完整的退出通道使用示例。在这个示例中，等待一定的时间后向退出通道发送了消息。但在实际工作中，具体等待多长时间可能取决于程序其他地方的未知事件何时发生。

package main

import (
    "fmt"
    "time"
)

func sender(c chan string){
    t := time.NewTicker(time.Second * 1)
    for{
        c <- "i'm sending a msg"
        <-t.C
    }
}

func main() {
    messages := make (chan string)
    stop := make(chan bool)
    
    go sender(messages)
    
    go func(){
        time.Sleep(time.Second * 2)
        fmt.Println("time is up")
        stop <- true
    }()

    for {
        select{
            case <-stop:
                return
            case msg := <- messages:
                fmt.Println(msg)
        }
    }
}

运行结果

i'm sending a msg
i'm sending a msg
time is up

12.8 问与答

问：关闭通道时会导致缓冲的消息丢失吗？

答：关闭缓冲通道意味着不能再向它发送消息。缓冲的消息会被保留，可供接收者读取。