Effective Go(有效的 GO)[4]

并发

通过通信共享

不要通过共享内存进行通信；相反，通过通信共享内存。

Goroutines

go list.Sort()  // 并发运行 list.Sort；不等待它完成。

func Announce(message string, delay time.Duration) {
    go func() {
        time.Sleep(delay)
        fmt.Println(message)
    }()  // 注意括号 - 必须调用该函数。
}

通道

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

c := make(chan int)  // 分配一个通道。
// 在 goroutine 中启动排序；完成后在通道上发送信号。
go func() {
    list.Sort()
    c <- 1  // 发送信号；值无关紧要。
}()
doSomethingForAWhile()
<-c   // 等待排序完成；丢弃发送的值。

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 完成。
    }
}

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

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  // 等待退出信号。
}

通道的通道

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)

func handle(queue chan *Request) {
    for req := range queue {
        req.resultChan <- req.f(req.args)
    }
}

并行化

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    // 信号表示这一部分完成
}

const numCPU = 4 // CPU 核心数量

func (v Vector) DoAll(u Vector) {
    c := make(chan int, numCPU)  // 缓冲是可选的，但合理。
    for i := 0; i < numCPU; i++ {
        go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
    }
    // 清空通道。
    for i := 0; i < numCPU; i++ {
        <-c    // 等待一个任务完成
    }
    // 完成所有操作。
}

var numCPU = runtime.NumCPU()

var numCPU = runtime.GOMAXPROCS(0)

漏水的缓冲区

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:
            // 空闲列表已满，继续进行。
        }
    }
}

错误处理

type error interface {
    Error() string
}

// PathError 记录了导致错误的操作和文件路径。
type PathError struct {
    Op   string // "open", "unlink" 等
    Path string // 相关文件
    Err  error  // 系统调用返回的错误
}

func (e *PathError) Error() string {
    return e.Op + " " + e.Path + ": " + e.Err.Error()
}

open /etc/passwx: no such file or directory

for try := 0; try < 2; try++ {
    file, err = os.Create(filename)
    if err == nil {
        return
    }
    if e, ok := err.(*os.PathError); ok && e.Err == syscall.ENOSPC {
        deleteTempFiles()  // 回收一些空间。
        continue
    }
    return
}

恐慌处理

// 使用牛顿法实现立方根的简单示例。
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))
}

var user = os.Getenv("USER")

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

恢复处理

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)
}

// Error 是解析错误的类型；它满足 error 接口。
type Error string
func (e Error) Error() string {
    return string(e)
}

// error 是 *Regexp 的一个方法，通过
// 使用 panic 处理解析错误。
func (regexp *Regexp) error(err string) {
    panic(Error(err))
}

// Compile 返回正则表达式的解析表示。
func Compile(str string) (regexp *Regexp, err error) {
    regexp = new(Regexp)
    // doParse 如果有解析错误将会 panic。
    defer func() {
        if e := recover(); e != nil {
            regexp = nil    // 清除返回值。
            err = e.(Error) // 如果不是解析错误将重新 panic。
        }
    }()
    return regexp.doParse(str), nil
}

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

一个 Web 服务器

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>
`