在golangweekly的第36期Go Newsletter中我发现一篇短文"How Goroutines Work" ，其作者在参考了诸多资料后，简短概要地总结了一下 Goroutine的工作原理，感觉十分适合刚入门的Gophers（深入理解Goroutine调度的话，可以参考Daniel Morsing的" The Go scheduler" )。这里粗译如下。

一、Go语言简介

如果你是Go语言新手，或如果你对"并发(Concurrency)不是并行(parallelism)"这句话毫无赶脚，那么请看一下Rob Pike大神关于这个主题的演讲吧，演讲共30分 钟，我敢保证你在这个演讲上花费30分钟是绝对值得的。

总结一下两者（Concurrency和Parallelism）的不同："当人们听到并发（Concurrency)这个词时，总是会想起并行 （Parallelism），它们之间有相关性，但却是两个明显不同的概念。在编程领域，并发（Concurrency）是独立的执行过程 (Process)的组合，而并行（Parallelism)则是计算（可能是相关联的）的同时执行。并发（Concurrency)是关于同时 应对很多事情(deal with lots of things)，而并行（Parallelism)则是同时做许多事情(do lots of things)"。(Rob Pike的“Concurrency is not parallelism")

Go语言支持我们编写并发(Concurrent)的程序。它提供了Goroutine以及更重要的在Goroutines之间通信的能力。这里 我们将聚焦在前者（译注：指并发）。

二、Goroutines和Threads

Goroutine是一个简单的模型：它是一个函数，与其他Goroutines并发执行且共享相同地址空间。Goroutines的通常用法是根据需要创建尽可 能的Groutines，成百上千甚至上万的。这种用法对于那些习惯了使用C++或Java的程序员来讲可能会有些奇怪。创建这么多 goroutines势必要付出不菲的代价？一个操作系统线程使用固定大小的内存作为它的执行栈，当线程数增多时，线程间切换的代价也是相当的 高。这也是每处理一个request就创建一个新线程的服务程序方案被诟病的原因。

不过Goroutine完全不同。它们由Go运行时初始化并调度，操作系统根本看不到Goroutine的存在。所有的goroutines都是 活着的，并且以多路复用的形式运行于操作系统为应用程序分配的少数几个线程上。创建一个Goroutine并不需要太多内存，只需要8K的栈空间 （在Go 1.3中这个Size发生了变化）。它们根据需要在堆上分配和释放内存以实现自身的增长。

Go运行时负责调度Goroutines。Goroutines的调度是协作式的，而线程不是。这意味着每次一个线程发生切换，你都需要保存/恢 复所有寄存器，包括16个通用寄存器、PC(程序计数器）、SP（栈指针）、段寄存器(segment register)、16个XMM寄存器、FP协处理器状态、X AVX寄存器以及所有MSR等。而当另一个Goroutine被调度时，只需要保存/恢复三个寄存器，分别是PC、SP和DX。Go调度器和任何现代操作 系统的调度器都是O(1)复杂度的，这意味着增加线程/goroutines的数量不会增加切换时间，但改变寄存器的代价是不可忽视的。

由于Goroutines的调度是协作式的，一个持续循环的goroutine会导致运行于同一线程上的其他goroutines“饿死”。在 Go 1.2中，这个问题或多或少可以通过在进入函数前间或地调用Go调度器来缓解一些，因此一个包含非内联函数调用的循环是可以被调度器抢占的。

三、Goroutine阻塞

只要阻塞存在，它在OS线程中就是不受欢迎的，因为你拥有的线程数量很少。如果你发现大量线程阻塞在网络操作或是Sleep操作上，那就是问题， 需要修正。正如前面提到的那样，Goroutine是廉价的。更关键地是，如果它们在网络输入操作、Sleep操作、Channel操作或 sync包的原语操作上阻塞了，也不会导致承载其多路复用的线程阻塞。如果一个goroutine在上述某个操作上阻塞，Go运行时会调度另外一 个goroutine。即使成千上万的Goroutine被创建了出来，如果它们阻塞在上述的某个操作上，也不会浪费系统资源。从操作系统的视角来看，你的程序的行为就像是一个事件驱动的C程序似的。

四、最后的想法

就是这样，Goroutines可以并发的运行。不过和其他语言一样，组织两个或更多goroutine同时访问共享资源是很重要的。最好采用Channel在不同Goroutine间传递数据。

最后，虽然你无法直接控制Go运行时创建的线程的数量，但可以通过调用runtime.GOMAXPROCS(n)方法设置变量GOMAXPROCS来设 定使用的处理器核的数量。提高使用的处理器核数未必能提升你的程序的性能，这取决于程序的设计。程序剖析诊断工具(profiling tool)可以用来检查你的程序使用处理器核数的真实情况。

中午闲暇翻看Daniel Morsing的“The Go scheduler”时，发现其另外一篇短文“Effective error handling in Go”，文章不长，但感觉对Go中错误处理方法总结的还是比较到位的，这里译之供大家参考。

一、简介

Go语言受到诟病最多的一项就是其错误处理机制。如果显式地检查和处理每个error，这恐怕的确会让人望而却步。你可以试试这里列出的几个方法，以避免你走入错误处理方法的误区当中去。

二、在缩进区处理错误

当使用Go语言编写代码时，首选下面这样的错误处理方法：

f, err := os.Open(path)
if err != nil {
    // handle error
}
// do stuff

而不是下面这样的：

f, err := os.Open(path)
if err == nil {
    // do stuff
}
// handle error

按照上面的方法处理错误，处理正常情况的代码读起来就显得通篇连贯了。

三、定义你自己的errors

做好如何正确进行错误处理的第一步就是要了解error是什么。如果你设计实现的包会因某种原因发生某种错误，你的包用户将会对错误的原因很感兴趣。为了满足用户的需求，你需要实现error接口，简单做起来就像这样：

type Error string
func (e Error) Error() string { return string(e) }

现在，你的包用户通过执行一个type assertion就可以知道是否是你的包导致了这个错误：

result, err := yourpackage.Foo()
if ype, ok := err.(yourpackage.Error); ok {
    // use ype to handle error
}

通过这个方法，你还可以向你的包用户暴露更多地结构化错误信息：

type ParseError struct {
    File  *File
    Error string
}

func (oe *ParseError) Error() string {//译注：原文中这里是OpenError
    // format error string here
}

func ParseFiles(files []*File) error {
    for _, f := range files {
        err := f.parse()
        if err != nil {
            return &ParseError{ //译注：原文中这里是OpenError
                File:  f,
                Error: err.Error(),
            }
        }
    }
}

通过这种方法，你的用户就可以明确地知道到底哪个文件出现解析错误了。（译注：从这里看到的go语言error设计之内涵，让我想起了Rob Pike大神的一篇Blog："少即是级数级的多"）

不过包装error时要小心，当你将一个error包装起来后，你可能会丢失一些信息：

var c net.Conn
f, err := DownloadFile(c, path)
switch e := err.(type) {
default:
    // this will get executed if err == nil
case net.Error:
    // close connection, not valid anymore
    c.Close()
    return e
case error:
    // if err is non-nil
    return err
}
// do other things.

如果你包装了net.Error，上面这段代码将无法知道是由于网络问题导致的失败，会继续使用这条无效的链接。

有一条经验规则：如果你的包中使用了一个外部interface，那么不要对这个接口中方法返回的任何错误，使用你的包的用户可能更关心这些错误，而不是你包装后的错误。

四、将错误作为状态

有时，当遇到一个错误时，你可能会停下来等等。这或是因为你将延迟报告错误，又或是因为你知道如果这次报告后，后续你会再报告同样的错误。

第一种情况的一个例子就是bufio包。当一个bufio.Reader遇到一个错误时，它将停下来保持这个状态，直到buffer已经被清空。只有在那时它才会报告错误。

第二种情况的一个例子是go/loader。当你通过某些参数调用它导致错误时，它会停下来保持这个状态，因为它知道你很可能会使用同样地参数再次调用它。

五、使用函数以避免重复代码

如果你有两段重复的错误处理代码，你可以将它们放到一个函数中去：

func handleError(c net.Conn, err error) {
    // repeated error handling
}

func DoStuff(c net.Conn) error {
    f, err := downloadFile(c, path)
    if err != nil {
        handleError(c, err)
        return err
    }

    f, err := doOtherThing(c)
    if err != nil {
        handleError(c, err)
        return err
    }
}

优化后的实现方法如下：

func handleError(c net.Conn, err error) {
    if err == nil {
        return
    }
    // repeated error handling
}

func DoStuff(c net.Conn) error {
    defer func() { handleError(c, err) }()
    f, err := downloadFile(c, path)
    if err != nil {
        return err
    }

    f, err := doOtherThing(c)
    if err != nil {
        return err
    }
}

这就是全部了。就Go语言错误处理而言，我知道的就这么多了。