格式化

• gofmt是一个cli程序，会优先读取标准输入，如果传入了文件路径的话，会格式化这个文件，如果传入一个目录，会格式化目录中所有.go文件，如果不传参数，会格式化当前目录下的所有.go文件

注释

• 命令godoc是一个很强大的工具，同样用于展示指定代码包的文档

https://www.jianshu.com/p/b91c4400d4b2

• 在程序中，每个可导出（首 字母大写）的名称都应该有文档注释

命名

• 包应当以小写的单个单词来命名，且不应使用下划线或驼峰记法

• 它并不需要在所有源码中保持唯一，即便在少数发生冲突的情 况下， 也可为导入的包选择一个别名来局部使用。

• 包的导入者可通过包名来引用其内容，因此包中的可导出名称可以此来避免冲突。 （请勿使 用 import . 记法，它可以简化必须在被测试包外运行的测试， 除此之外应尽量避免使用。） 例如，bufio 包中的缓存读取器类型叫做 Reader 而非 BufReader，因为用户将它看做 bufio.Reader，这是个清楚而简洁的名称。

• GetOwner。大写字母即为可导出的这种规定为区分方法和字段提供了便利。

• 按照约定，只包含一个方法的接口应当以该方法的名称加上 - er 后缀来命名，如 Reader、 Writer、 Formatter、CloseNotifier 等。诸如此类的命名有很多，遵循它们及其代表的函数名会让事情变得简单。 Read、Write、 Close、Flush、 String 等都具有典型的签名和意义。为避免冲突，请不要用这些名称为你的 方法命名， 除非你明确知道它们的签名和意义相同。反之，若你的类型实现了的方法， 与一 个众所周知的类型的方法拥有相同的含义，那就使用相同的命名。

• Go 中约定使用驼峰记法 MixedCaps 或 mixedCaps。

分号

• 无论如何，你都不应将一个控制结构（if、for、switch 或 select）的左大括号放在下一 行。如果这样做，就会在大括号前面插入一个分号，这可能引起不需要的效果。

控制结构

与C语言差异

• Go 不再使用 do 或 while 循环，只有一个更通用的 for；switch 要更灵活一点；if 和 switch 像 for 一样可接受可选 的初始化语句； 此外，还有一个包含类型选择和多路通信复用器的新控制结构：select。 其 语法也有些许不同：没有圆括号，而其主体必须始终使用大括号括住。

重新声明与再次赋值

• 在满足下列条件时，已被声明的变量 v 可出现在:= 声明中：

（1）本次声明与已声明的 v 处于同一作用域中（若 v 已在外层作用域中声明过，则此次声明 会创建一个新的变量 §）

（2）在初始化中与其类型相应的值才能赋予 v，且

（3）在此次声明中至少另有一个变量是新声明的。

For

// 如同 C 的 for 循环 
for init; condition; post { } 
// 如同 C 的 while 循环 
for condition { } 
// 如同 C 的 for(;;) 循环 
for { }

若你想遍历数组、切片、字符串或者映射，或从信道中读取消息， range 子句能够帮你轻松 实现循环。

for key, value := range oldMap { 
	newMap[key] = value 
}



switch

• Go 的 switch 比 C 的更通用。其表达式无需为常量或整数，case 语句会自上而下逐一进行求 值直到匹配为止。若 switch 后面没有表达式，它将匹配 true，因此，我们可以将 if-else-ifelse 链写成一个 switch，这也更符合 Go 的风格。

• switch 并不会自动下溯，但 case 可通过逗号分隔来列举相同的处理条件。

func shouldEscape(c byte) bool { 
	switch c { 
	case ' ', '?', '&', '=', '#', '+', '%': 
		return true 
	} 
	return false
}



函数

多值返回

• Go 与众不同的特性之一就是函数和方法可返回多个值。这种形式可以改善 C 中一些笨拙的习 惯： 将错误值返回（例如用 -1 表示 EOF）和修改通过地址传入的实参。

可命名结果形参

• Go 函数的返回值或结果 “形参” 可被命名，并作为常规变量使用，就像传入的形参一样。 命 名后，一旦该函数开始执行，它们就会被初始化为与其类型相应的零值； 若该函数执行了一 条不带实参的 return 语句，则结果形参的当前值将被返回。

Defer

• Go 的 defer 语句用于预设一个函数调用（即推迟执行函数）， 该函数会在执行 defer 的函数 返回之前立即执行。被推迟函数的实参（如果该函数为方法则还包括接收者）在推迟执行时就会求值， 而不是在 调用执行时才求值。被推迟的函数按照后进先出（LIFO）的顺序执行

数据

new 分配

• Go 提供了两种分配原语，即内建函数 new 和 make。 它们所做的事情不同，所应用的类型 也不同。它们可能会引起混淆，但规则却很简单。 让我们先来看看 new。这是个用来分配内 存的内建函数， 但与其它语言中的同名函数不同，它不会初始化内存，只会将内存置零。 也 就是说，new(T) 会为类型为 T 的新项分配已置零的内存空间， 并返回它的地址，也就是一个 类型为 *T 的值。用 Go 的术语来说，它返回一个指针， 该指针指向新分配的，类型为 T 的 零值。

构造函数与复合字面

• 复合字面的字段必须按顺序全部列出。但如果以 字段: 值 对的形式明确地标出元素，初始化 字段时就可以按任何顺序出现，未给出的字段值将赋予零值。

make 分配

• 再回到内存分配上来。内建函数 make(T, args) 的目的不同于 new(T)。它只用于创建切片、 映射和信道，并返回类型为 T（而非 *T ）的一个已初始化 （而非置零）的值。 出现这种用 差异的原因在于，这三种类型本质上为引用数据类型，它们在使用前必须初始化。 例如，切 片是一个具有三项内容的描述符，包含一个指向（数组内部）数据的指针、长度以及容量， 在这三项被初始化之前，该切片为 nil。对于切片、映射和信道，make 用于初始化其内部的 数据结构并准备好将要使用的值。例如， make([]int, 10, 100)

数组

• 以下为数组在 Go 和 C 中的主要区别。在 Go 中， 数组是值。将一个数组赋予另一个数组会复制其所有元素。 特别地，若将某个数组传入某个函数，它将接收到该数组的一份副本而非指针。 数组的大小是其类型的一部分。类型 [10]int 和 [20]int 是不同的。

切片

• 切片保存了对底层数组的引用，若你将某个切片赋予另一个切片，它们会引用同一个数组。 若某个函数将一个切片作为参数传入，则它对该切片元素的修改对调用者而言同样可见， 这 可以理解为传递了底层数组的指针。因此，Read 函数可接受一个切片实参 而非一个指针和 一个计数；切片的长度决定了可读取数据的上限。以下为 os 包中 File 类型的 Read 方法签 名:

func (file `*`File) Read(buf []byte) (n int, err error)



二维切片

• Go 的数组和切片都是一维的。要创建等价的二维数组或切片，就必须定义一个数组的数组， 或切片的切片，就像这样：

type Transform [3][3]float64 // A 3x3 array, really an array of arrays. 
type LinesOfText [][]byte // A slice of byte slices.

由于切片长度是可变的，因此其内部可能拥有多个不同长度的切片。在我们的 LinesOfText 例 子中，这是种常见的情况：每行都有其自己的长度。

text := LinesOfText{ 
	[]byte("Now is the time"), 
	[]byte("for all good gophers"), 
	[]byte("to bring some fun to the party."), 
}



• 有时必须分配一个二维数组，例如在处理像素的扫描行时，这种情况就会发生。 我们有两种 方式来达到这个目的。一种就是独立地分配每一个切片；而另一种就是只分配一个数组， 将 各个切片都指向它。采用哪种方式取决于你的应用。若切片会增长或收缩， 就应该通过独立 分配来避免覆盖下一行；若不会，用单次分配来构造对象会更加高效。 以下是这两种方法的 大概代码，仅供参考。

(1)首先是一次一行的：

// 分配顶层切片。 
picture := make([][]uint8, YSize) // 每 y 个单元一行。 
// 遍历行，为每一行都分配切片 
for i := range picture { 
	picture[i] = make([]uint8, XSize) 
}

(2)现在是一次分配，对行进行切片：

// 分配顶层切片，和前面一样。 
picture := make([][]uint8, YSize) // 每 y 个单元一行。 
// 分配一个大的切片来保存所有像素 
pixels := make([]uint8, XSize*YSize) // 拥有类型 []uint8，尽管图片是 [][]uint8. 
// 遍历行，从剩余像素切片的前面切出每行来。 
for i := range picture { 
	picture[i], pixels = pixels[:XSize], pixels[XSize:]
}



映射

• 映射是方便而强大的内建数据结构，它可以关联不同类型的值。其键可以是任何相等性操作 符支持的类型， 如整数、浮点数、复数、字符串、指针、接口（只要其动态类型支持相等性 判断）、结构以及数组。 切片不能用作映射键，因为它们的相等性还未定义。与切片一样， 映射也是引用类型。 若将映射传入函数中，并更改了该映射的内容，则此修改对调用者同样 可见。

打印

• 当然，映射中的键可能按任意顺序输出。当打印结构体时，改进的格式 %+v 会为结构体的每 个字段添上字段名，而另一种格式 %#v 将完全按照 Go 的语法打印值。

type T struct {
	a int 
	b float64 
	c string 
} 
t := &T{ 7, -2.35, "abc\tdef" } 
fmt.Printf("%v\n", t) 
fmt.Printf("%+v\n", t) 
fmt.Printf("%#v\n", t) 
fmt.Printf("%#v\n", timeZone) 
// prints 将打印 
&{7 -2.35 abc def} 
&{a:7 b:-2.35 c:abc def} 
&main.T{a:7, b:-2.35, c:"abc\tdef"} 
map[string] int{"CST":-21600, "PST":-28800, "EST":-18000, "UTC":0, "MST":-25200}



• 我们的 String 方法也可调用 Sprintf， 因为打印例程可以完全重入并按这种方式封装。不过要 理解这种方式，还有一个重要的细节： 请勿通过调用 Sprintf 来构造 String 方法，因为它会无 限递归你的的 String 方法。

type MyString string func (m MyString) String() string { return fmt.Sprintf("MyString=%s", m) // 错误：会无限递归 
}



初始化

init 函数

• 每个源文件都可以通过定义自己的无参数 init 函数来设置一些必要的状态。 （其实每 个文件都可以拥有多个 init 函数。）而它的结束就意味着初始化结束： 只有该包中的所有变 量声明都通过它们的初始化器求值后 init 才会被调用， 而那些 init 只有在所有已导入的包都 被初始化后才会被求值。

方法

指针 vs. 值

• 在之前讨论切片时，我们编写了一个 Append 函数。 我们也可将其定义为切片的方法。为 此，我们首先要声明一个已命名的类型来绑定该方法， 然后使该方法的接收者成为该类型的 值。

type ByteSlice []byte
func (slice ByteSlice) Append(data []byte) []byte { 
	// 主体和前面相同。 
}



• 我们仍然需要该方法返回更新后的切片。为了消除这种不便，我们可通过重新定义该方法， 将一个指向 ByteSlice 的指针作为该方法的接收者， 这样该方法就能重写调用者提供的切片 了。

其实我们做得更好。若我们将函数修改为与标准 Write 类似的方法，就像这样，

func (p *ByteSlice) Write(data []byte) (n int, err error) { 
	slice := *p 
	// 依旧和前面相同。 
	*p = slice 
	return len(data), nil 
}

那么类型 *ByteSlice 就满足了标准的 io.Writer 接口，这将非常实用。 例如，我们可以通过 打印将内容写入。

var b ByteSlice 
fmt.Fprintf(&b, "This hour has %d days\n", 7)

• 我们将 ByteSlice 的地址传入，因为只有 *ByteSlice 才满足 io.Writer。以指针或值为接收者 的区别在于：值方法可通过指针和值调用， 而指针方法只能通过指针来调用。



• 之所以会有这条规则是因为指针方法可以修改接收者；通过值调用它们会导致方法接收到该 值的副本， 因此任何修改都将被丢弃，因此该语言不允许这种错误。不过有个方便的例外： 若该值是可寻址的， 那么该语言就会自动插入取址操作符来对付一般的通过值调用的指针方 法。在我们的例子中，变量 b 是可寻址的，因此我们只需通过 b.Write 来调用它的 Write 方 法，编译器会将它重写为 (&b).Write。



• 顺便一提，在字节切片上使用 Write 的想法已被 bytes.Buffer 所实现。

接口与其它类型

接口

• Go中的接口为指定对象的行为提供了一种方法：如果某样东西可以完成这个，那么它就可以用在这里。我们已经见过许多简单的示例了；通过实现 String 方法，我们可以自定义打印函数，而通过 Write 方法，Fprintf 则能对任何对象产生输出。在 Go 代码中，仅包含一两种方法的接口很常见，且其名称通常来自于实现它的方法，如 io.Writer 就是实现了 Write 的一类对象。

• 每种类型都能实现多个接口。例如一个实现了 sort.Interface 接口的集合就可通过 sort 包中的 例程进行排序。该接口包括 Len()、Less(i, j int) bool 以及 Swap(i, j int)，另外，该集合仍然可 以有一个自定义的格式化器。 以下特意构建的例子 Sequence 就同时满足这两种情况。

type Sequence []int 
// Methods required by sort.Interface. 
// sort.Interface 所需的方法。 
func (s Sequence) Len() int {
	return len(s) 
} 
func (s Sequence) Less(i, j int) bool {
	return s[i] < s[j] 
} 
func (s Sequence) Swap(i, j int) { 
	s[i], s[j] = s[j], s[i] 
} 
// Method for printing - sorts the elements before printing. 
// 用于打印的方法 - 在打印前对元素进行排序。 
func (s Sequence) String() string { 
	sort.Sort(s) 
	str := "[" 
	for i, elem := range s { 
		if i > 0 { 
			str += " " 
		} 
		str += fmt.Sprint(elem) 
	} 
	return str + "]"
}



类型转换

• 该方法是通过类型转换技术，在 String 方法中安全调用 Sprintf 的另个一例子。若我们忽略类 型名的话，这两种类型（Sequence 和 []int）其实是相同的，因此在二者之间进行转换是合法 的。 转换过程并不会创建新值，它只是值暂让现有的时看起来有个新类型而已。 （还有些合 法转换则会创建新值，如从整数转换为浮点数等。）



接口转换与类型断言

• 类型选择 是类型转换的一种形式：它接受一个接口，在选择 （switch）中根据其判断选择对 应的情况（case）， 并在某种意义上将其转换为该种类型。以下代码为 fmt.Printf 通过类型 选择将值转换为字符串的简化版。若它已经为字符串，我们需要该接口中实际的字符串值； 若它有 String 方法，我们则需要调用该方法所得的结果。



• 类型断言 若它所转换的值中不包含字符串，该程序就会以运行时错误崩溃。为避免这种情况， 需使 用 “逗号, ok” 惯用测试它能安全地判断该值是否为字符串：

str, ok := value.(string) 
if ok 
{ 
	fmt.Printf("string value is: %q\n", str) 
} else {
 fmt.Printf("value is not a string\n")
}



空白标识符

• 若某次赋值需要匹配多个左值，但其中某个变量不会被程序使用， 那么用空白标识符来代替 该变量可避免创建无用的变量，并能清楚地表明该值将被丢弃。 例如，当调用某个函数时， 它会返回一个值和一个错误，但只有错误很重要， 那么可使用空白标识符来丢弃无关的值。

if _, err := os.Stat(path); os.IsNotExist(err) {
	fmt.Printf("%s does not exist\n", path) 
}



• 要让编译器停止关于未使用导入的抱怨，需要空白标识符来引用已导入包中的符号。 同样， 将未使用的变量 fd 赋予空白标识符也能关闭未使用变量错误。 该程序的以下版本可以编译。

package main 
import (
	"fmt" 
	"io" 
	"log" 
	"os" 
) 
var _ = fmt.Printf // For debugging; delete when done. // 用于调试，结束时删除。 
var _ io.Reader // For debugging; delete when done. // 用于调试，结束时删除。 
func main() { 
	fd, err := os.Open("test.go") 
	if err != nil { 
		log.Fatal(err) 
	} 
	// TODO: use fd. 
	_ = fd 
}



• 像前例中 fmt 或 io 这种未使用的导入总应在最后被使用或移除： 空白赋值会将代码标识为工 作正在进行中。但有时导入某个包只是为了其副作用， 而没有任何明确的使用。例如，在 net/http/pprof 包的 init 函数中记录了 HTTP 处理程序的调试信息。它有个可导出的 API， 但 大部分客户端只需要该处理程序的记录和通过 Web 叶访问数据。只为了其副作用来哦导入该 包， 只需将包重命名为空白标识符：

import _ "net/http/pprof" 

这种导入格式能明确表示该包是为其副作用而导入的，因为没有其它使用该包的可能： 在此 文件中，它没有名字。（若它有名字而我们没有使用，编译器就会拒绝该程序。）



内嵌

• 若我们需要直接引用内嵌字段，可以忽略包限定名，直接将该字段的类型名作为字段名， 就 像我们在 ReaderWriter 结构体的 Read 方法中做的那样。 若我们需要访问 Job 类型的变量 job 的 *log.Logger ， 可以直接写作 job.Logger。若我们想精炼 Logger 的方法时， 这会非 常有用。



并发

通过通信共享内存

• 在并发编程中，为实现对共享变量的正确访问需要精确的控制，这在多数环境下都很困难。 Go语言另辟蹊径，它将共享的值通过信道传递，实际上，多个独立执行的线程从不会主动共享。在任意给定的时间点，只有一个Go程能够访问该值。数据竞争从设计上就被杜绝了。 为了提倡这种思考方式，我们将它简化为一句口号：

不要通过共享内存来通信，而应通过通信来共享内存。



Goroutines Go程

• 我们称之为 Go程是因为现有的术语—线程、协程、进程等等—无法准确传达它的含义。Go程具有简单的模型：它是与其它Go程并发运行在同一地址空间的函数。它是轻量级的，所有小号几乎就只有栈空间的分配。而且栈最开始是非常小的，所以它们很廉价，仅在需要时才会随着堆空间的分配（和释放）而变化。



• Go程在多线程操作系统上可实现多路复用，因此若一个线程阻塞，比如说等待 I/O，那么其它的线程就会运行。Go程的设计隐藏了线程创建和管理的诸多复杂性。



• 在函数或方法前添加 go 关键字能够在新的 Go程中调用它。当调用完成后，该 Go程也会安静地退出。（效果有点像 Unix Shell 中的 & 符号，它能让命令在后台运行。）

go list.Sort() // 并发运行 list.Sort，无需等它结束。



Channels 信道

• 信道与映射一样，也需要通过 make 来分配内存。其结果值充当了对底层数据结构的引用。 若提供了一个可选的整数形参，它就会为该信道设置缓冲区大小。默认值是零，表示不带缓 冲的或同步的信道。

ci := make(chan int) // 整数类型的无缓冲信道 
cj := make(chan int, 0) // 整数类型的无缓冲信道 
cs := make(chan *os.File, 100) // 指向文件指针的带缓冲信道



• 无缓冲信道在通信时会同步交换数据，它能确保（两个 Go 程的）计算处于确定状态。



• 信道有很多惯用法，我们从这里开始了解。在上一节中，我们在后台启动了排序操作。 信道 使得启动的 Go 程等待排序完成。

c := make(chan int) // 分配一个信道 
// 在 Go 程中启动排序。当它完成后，在信道上发送信号。 
go func() { 
	list.Sort() 
	c <- 1 // 发送信号，什么值无所谓。 
}() 
doSomethingForAWhile() 
<-c // 等待排序结束，丢弃发来的值。



• 接收者在收到数据前会一直阻塞。若信道是不带缓冲的，那么在接收者收到值前， 发送者会 一直阻塞；若信道是带缓冲的，则发送者仅在值被复制到缓冲区前阻塞； 若缓冲区已满，发 送者会一直等待直到某个接收者取出一个值为止。



• 带缓冲的信道可被用作信号量，例如限制吞吐量。在此例中，进入的请求会被传递给 handle，它从信道中接收值，处理请求后将值发回该信道中，以便让该 “信号量” 准备迎接下 一次请求。信道缓冲区的容量决定了同时调用 process 的数量上限，因此我们在初始化时首 先要填充至它的容量上限。

var sem = make(chan int, MaxOutstanding) 
func handle(r *Request) { 
	sem <- 1 // 等待活动队列清空。 
	process(r) // 可能需要很长时间。 
	<-sem // 完成；使下一个请求可以运行。 
} 
func Serve(queue chan *Request) { 
	for { 
		req := <-queue 
		go handle(req) // 无需等待 handle 结束。 
	} 
}



• 由于数据同步发生在信道的接收端（也就是说发送发生在 > 接受之前，参见 Go 内存模 型），因此信号必须在信道的接收端获取，而非发送端。



• 然而，它却有个设计问题：尽管只有 MaxOutstanding 个 Go 程能同时运行，但 Serve 还是为 每个进入的请求都创建了新的 Go 程。其结果就是，若请求来得很快， 该程序就会无限地消 耗资源。为了弥补这种不足，我们可以通过修改 Serve 来限制创建 Go 程，这是个明显的解 决方案，但要当心我们修复后出现的 Bug。

func Serve(queue chan *Request) { 
	for req := range queue { 
		sem <- 1 
		go func() { 
			process(req) // 这儿有 Bug，解释见下。 
			<-sem 
		}() 
	} 
}



• Bug 出现在 Go 的 for 循环中，该循环变量在每次迭代时会被重用，因此 req 变量会在所有的 Go 程间共享，这不是我们想要的。我们需要确保 req 对于每个 Go 程来说都是唯一的。有一 种方法能够做到，就是将 req 的值作为实参传入到该 Go 程的闭包中：

func Serve(queue chan *Request) { 
	for req := range queue { 
		sem <- 1 
		go func(req *Request) { 
			process(req) 
			<-sem 
		}(req)
	} 
}



• 比较前后两个版本，观察该闭包声明和运行中的差别。 另一种解决方案就是以相同的名字创 建新的变量，如例中所示：

func Serve(queue chan *Request) { 
	for req := range queue { 
		req := req // 为该 Go 程创建 req 的新实例。 
		sem <- 1 
		go func() { 
			process(req) 
			<-sem 
		}() 
	} 
}



• 它的写法看起来有点奇怪req := req。但在 Go 中这样做是合法且惯用的。你用相同的名字获得了该变量的一个新的版本， 以此来 局部地刻意屏蔽循环变量，使它对每个 Go 程保持唯一。



• 回到编写服务器的一般问题上来。另一种管理资源的好方法就是启动固定数量的 handle Go 程，一起从请求信道中读取数据。Go 程的数量限制了同时调用 process 的数量。Serve 同样 会接收一个通知退出的信道， 在启动所有 Go 程后，它将阻塞并暂停从信道中接收消息。

func handle(queue chan *Request) { 
	for r := range queue { 
		process(r) 
	} 
} 
func Serve(clientRequests chan *Request, quit chan bool) { 
	// 启动处理程序 
	for i := 0; i < MaxOutstanding; i++ { 
		go handle(clientRequests) 
	} 
	<-quit // 等待通知退出。 
}



信道中的信道

• Go最重要的特性就是信道是一等值，它可以被分配并像其它值到处传递。 这种特性通常被用 来实现安全、并行的多路分解。



• 在上一节的例子中，handle 是个非常理想化的请求处理程序， 但我们并未定义它所处理的请 求类型。若该类型包含一个可用于回复的信道， 那么每一个客户端都能为其回应提供自己的 路径。以下为 Request 类型的大概定义。

type Request struct { 
	args []int 
	f func([]int) int 
	resultChan chan int 
} 

客户端提供了一个函数及其实参，此外在请求对象中还有个接收应答的信道



func sum(a []int) (s int) { 
	for _, v := range a { 
		s += v 
	} 
	return 
} 
request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
// 发送请求 
clientRequests <- request 
// 等待回应 
fmt.Printf("answer: %d\n", <-request.resultChan)



• 要使其实际可用还有很多工作要做，这些代码仅能实现一个速率有限、并行、非阻塞 RPC 系 统的 框架，而且它并不包含互斥锁。



并行化

• 这些设计的另一个应用是在多 CPU 核心上实现并行计算。如果计算过程能够被分为几块 可 独立执行的过程，它就可以在每块计算结束时向信道发送信号，从而实现并行处理。



• 让我们看看这个理想化的例子。我们在对一系列向量项进行极耗资源的操作，而每个项的值计算是完全独立的。



type Vector []float64 
// 将此操应用至 v[i], v[i+1] ... 直到 v[n-1] 
func (v Vector) DoSome(i, n int, u Vector, c chan int) { 
	for ; i < n; i++ { 
		v[i] += u.Op(v[i]) 
	} 
	c <- 1 
	// 发信号表示这一块计算完成。 
} 



• 我们在循环中启动了独立的处理块，每个 CPU 将执行一个处理。 它们有可能以乱序的形式 完成并结束，但这没有关系； 我们只需在所有 Go 程开始后接收，并统计信道中的完成信号 即可。

const NCPU = 4 // CPU 核心数 
func (v Vector) DoAll(u Vector) { 
	c := make(chan int, NCPU) 
	// 缓冲区是可选的，但明显用上更好 
	for i := 0; i < NCPU; i++ { 
		go v.DoSome(i*len(v)/NCPU, (i+1)*len(v)/NCPU, u, c) 
	} 
	// 排空信道。 
	for i := 0; i < NCPU; i++ { 
		<-c // 等待任务完成 
	} 
	// 一切完成。 
}



可能泄露的缓冲区

• 并发编程的工具甚至能很容易地表达非并发的思想。这里有个提取自 RPC 包的例子。 客户 端 Go 程从某些来源，可能是网络中循环接收数据。为避免分配和释放缓冲区， 它保存了一 个空闲链表，使用一个带缓冲信道表示。若信道为空，就会分配新的缓冲区。 一旦消息缓冲 区就绪，它将通过 serverChan 被发送到服务器。 serverChan.

var freeList = make(chan *Buffer, 100) 
var serverChan = make(chan *Buffer) 
func client() { 
	for { 
		var b *Buffer 
		// 若缓冲区可用就用它，不可用就分配个新的。 
		select { 
		case b = <-freeList: 
			// 获取一个，不做别的。 
		default: 
			// 非空闲，因此分配一个新的。 
			b = new(Buffer) 
		} 
		load(b) // 从网络中读取下一条消息。 
		serverChan <- b // 发送至服务器。 
	} 
}



• 服务器从客户端循环接收每个消息，处理它们，并将缓冲区返回给空闲列表。

func server() { 
	for { 
		b := <-serverChan // 等待工作。 
		process(b) // 若缓冲区有空间就重用它。 
		select { 
		case freeList <- b: 
			// 将缓冲区放大空闲列表中，不做别的。 
		default: 
			// 空闲列表已满，保持就好。 
		} 
	} 
}



• 客户端试图从 freeList 中获取缓冲区；若没有缓冲区可用， 它就将分配一个新的。服务器将 b 放回空闲列表 freeList 中直到列表已满，此时缓冲区将被丢弃，并被垃圾回收器回收。 （select 语句中的 default 子句在没有条件符合时执行，这也就意味着 selects 永远不会被阻 塞。）依靠带缓冲的信道和垃圾回收器的记录， 我们仅用短短几行代码就构建了一个可能导 致缓冲区槽位泄露的空闲列表。



错误

Panic

• 向调用者报告错误的一般方式就是将 error 作为额外的值返回。 标准的 Read 方法就是个众所 周知的实例，它返回一个字节计数和一个 error。但如果错误时不可恢复的呢？有时程序就是 不能继续运行。



• 为此，我们提供了内建的 panic 函数，它会产生一个运行时错误并终止程序 （但请继续看下 一节）。该函数接受一个任意类型的实参（一般为字符串），并在程序终止时打印。 它还能 表明发生了意料之外的事情，比如从无限循环中退出了。

// 用牛顿法计算立方根的一个玩具实现。 
func CubeRoot(x float64) float64 { 
	z := x/3 // 任意初始值 
	for i := 0; i < 1e6; i++ { 
		prevz := z 
		z -= (z*z*z-x) / (3*z*z) 
		if veryClose(z, prevz) { 
			return z 
		} 
	} 
	// 一百万次迭代并未收敛，事情出错了。 
	panic(fmt.Sprintf("CubeRoot(%g) did not converge", x)) 
}



• 这仅仅是个示例，实际的库函数应避免 panic。若问题可以被屏蔽或解决， 最好就是让程序继续运行而不是终止整个程序。一个可能的反例就是初始化： 若某个库真的不能让自己工作，且有足够理由产生 Panic，那就由它去吧。

var user = os.Getenv("USER") 
func init() { 
	if user == "" { 
		panic("no value for $USER") 
	} 
}



恢复

• 当panic被调用后（包括不明确的运行时错误，例如切片检索越界或类型断言失败），程序 将立刻终止当前函数的执行，并开始回溯Go程的栈，运行任何被推迟的函数。若回溯到达Go程栈的顶端，程序就会终止。不过我们可以用内建的recover函数来重新或来取回Go程的控制权限并使其恢复正常执行。



• 调用recover将停止回溯过程，并返回传入panic的实参。由于在回溯时只有被推迟函数中的代码在运行，因此recover只能在被推迟的函数中才有效。



• recover 的一个应用就是在服务器中终止失败的 Go 程而无需杀死其它正在执行的 Go 程。

func server(workChan <-chan *Work) { 
	for work := range workChan { 
		go safelyDo(work) 
	} 
} 
func safelyDo(work *Work) { 
	defer func() { 
		if err := recover(); err != nil { 
			log.Println("work failed:", err) 
		} 
	}() 
	do(work) 
}



• 在此例中，若 do(work) 触发了 Panic，其结果就会被记录， 而该 Go 程会被干净利落地结 束，不会干扰到其它 Go 程。我们无需在推迟的闭包中做任何事情， recover 会处理好这一 切。



• 由于直接从被推迟函数中调用 recover 时不会返回 nil， 因此被推迟的代码能够调用本身使用 了 panic 和 recover 的库函数而不会失败。例如在 safelyDo 中，被推迟的函数可能在调用 recover 前先调用记录函数，而该记录函数应当不受 Panic 状态的代码的影响。



• 通过恰当地使用恢复模式，do 函数（及其调用的任何代码）可通过调用 panic 来避免更坏的 结果。我们可以利用这种思想来简化复杂软件中的错误处理。 让我们看看 regexp 包的理想化 版本，它会以局部的错误类型调用 panic 来报告解析错误。以下是一个 error 类型的 Error 方 法和一个 Compile 函数的定义：

// Error 是解析错误的类型，它满足 error 接口。 
type Error string 
func (e Error) Error() string { 
	return string(e) 
} 
// error 是 *Regexp 的方法，它通过用一个 Error 触发 Panic 来报告解析错误。 
func (regexp *Regexp) error(err string) { 
	panic(Error(err)) 
} 
// Compile 返回该正则表达式解析后的表示。 
func Compile(str string) (regexp *Regexp, err error) { 
	regexp = new(Regexp) 
	// doParse will panic if there is a parse error. 
	defer func() { 
		if e := recover(); e != nil { 
			regexp = nil // 清理返回值。 
			err = e.(Error) // 若它不是解析错误，将重新触发 Panic。 
		} 
	}() 
	return regexp.doParse(str), nil 
}



• 若 doParse 触发了 Panic，恢复块会将返回值设为 nil —被推迟的函数能够修改已命名的返回值。在 err 的赋值过程中， 我们将通过断言它是否拥有局部类型 Error 来检查它。若它没有，类型断言将会失败，此时会产生运行时错误，并继续栈的回溯，仿佛一切从未中断过一样。 该检查意味着若发生了一些像索引越界之类的意外，那么即便我们使用了 panic 和 recover 来处理解析错误，代码仍然会失败。



• 通过适当的错误处理，error 方法（由于它是个绑定到具体类型的方法， 因此即便它与内建的 error 类型名字相同也没有关系） 能让报告解析错误变得更容易，而无需手动处理回溯的解析 栈：

if pos == 0 { 
	re.error("'*' illegal at start of expression") 
}



• 尽管这种模式很有用，但它应当仅在包内使用。Parse 会将其内部的 panic 调用转为 error 值，它并不会向调用者暴露出 panic。这是个值得遵守的良好规则。



• 顺便一提，这种重新触发Panic的惯用法会在产生实际错误时改变Panic的值。 然而，不管是原始的还是新的错误都会在崩溃报告中显示，因此问题的根源仍然是可见的。这种简单的重新触发Panic的模型已经够用了，毕竟他只是一次崩溃。但若你只想显示原始的值，也可以多写一点代码来过滤掉不需要的问题，然后用原始值再次触发Panic。这里就将这个练习留给读者了。



一个 Web 服务器

• 让我们以一个完整的 Go 程序作为结束吧，一个 Web 服务器。该程序其实只是个 Web 服务 器的重用。 Google 在 http://chart.apis.google.com 上提供了一个将表单数据自动转换为图表 的服务。不过，该服务很难交互， 因为你需要将数据作为查询放到 URL 中。此程序为一种数 据格式提供了更好的的接口： 给定一小段文本，它将调用图表服务器来生成二维码（QR 码），这是一种编码文本的点格矩阵。 该图像可被你的手机摄像头捕获，并解释为一个字符 串，比如 URL， 这样就免去了你在狭小的手机键盘上键入 URL 的麻烦。

package main 
import ( 
	"flag" 
	"html/template" 
	"log" 
	"net/http" 
) 
var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18 
var templ = template.Must(template.New("qr").Parse(templateStr)) 
func main() { 
	flag.Parse() 
	http.Handle("/", http.HandlerFunc(QR)) 
	err := http.ListenAndServe(*addr, nil) 
	if err != nil { 
		log.Fatal("ListenAndServe:", err) 
	} 
} 
func QR(w http.ResponseWriter, req *http.Request) { 
	templ.Execute(w, req.FormValue("s")) 
} 
const templateStr = ` 
<html> 
<head> 
<title>QR Link Generator</title> 
</head> 
<body> 
{{if .}} 
<img src="http://chart.apis.google.com/chart?chs=300x300&cht=qr&choe=UTF-8&chl={{.}}" 
/> 
<br> 
{{.}} 
<br> 
<br> 
{{end}} 
<form action="/" name=f method="GET">
<input maxLength=1024 size=70 name=s value="" title="Text to QR Encode">
<input type=submit value="Show QR" name=qr> 
</form> 
</body> 
</html>
`



• main 之前的代码应该比较容易理解。我们通过一个标志为服务器设置了默认端口。 模板变量 templ 正式有趣的地方。它构建的 HTML 模版将会被服务器执行并显示在页面中。 稍后我们 将详细讨论。



• main 函数解析了参数标志并使用我们讨论过的机制将 QR 函数绑定到服务器的根路径。然后 调用 http.ListenAndServe 启动服务器；它将在服务器运行时处于阻塞状态。



• QR 仅接受包含表单数据的请求，并为表单值 s 中的数据执行模板。



• 模板包 html/template 非常强大；该程序只是浅尝辄止。 本质上，它通过在运行时将数据项中 提取的元素（在这里是表单值）传给 templ.Execute 执行因而重写了 HTML 文本。 在模板文 本（templateStr）中，双大括号界定的文本表示模板的动作。 从 {{if .}} 到 {{end}} 的 代码段仅在当前数据项（这里是点 .）的值非空时才会执行。 也就是说，当字符串为空时，此 部分模板段会被忽略。



• 其中两段 {{.}} 表示要将数据显示在模板中 （即将查询字符串显示在 Web 页面上）。 HTML 模板包将自动对文本进行转义， 因此文本的显示是安全的。



• 你终于如愿以偿了：以几行代码实现的，包含一些数据驱动的HTML文本的Web服务器。 Go 语言强大到能让很多事情以短小精悍的方式解决。



欢迎大家关注我的公众号，一起探讨技术