14.10 多路复用

14.10.1 典型的客户端 - 服务端模式

Client-server 类的应用是协程（goroutine）和频道（channel）的大显身手的闪光点。

客户端可以是任何一种运行在任何设备上的，且需要来自服务端信息的一种程序，所以它需要发送请求。 服务端接收请求，做一些处理，然后把给客户端发送响应信息。在通常情况下，就是多个客户端（很多请求）对一个（或几个）服务端。一个常见例子就是我们使用的发送网页请求的客户端浏览器。然后一个 web 服务器将响应网页发回给浏览器。

在 Go 中，服务端通常会在一个协程（goroutine）里操作对一个客户端的响应，所以协程和客户端请求是一一对应的。一种典型的做法就是客户端请求本身包含了一个频道（channel），服务端可以用它来发送响应。

例如，一个请求结构体类似如下形式，内嵌了一个回复 channel：

type Request struct {
    a, b int;
    replyc chan int;
    // 请求内部的回复 channel 
}

或者更通常如下：

type Reply struct { ... }
type Request struct {
    arg1, arg2, arg3 some_type
    replyc chan *Reply
}

继续上面的简单形式，服务端可以在一个 goroutine 里面为每个请求都分配一个 run () 函数，这个函数会把 binOp 类型的操作作用于整数，然后通过回复 channel 发送结果：

type binOp func(a, b int) int
func run(op binOp, req *Request) {
    req.replyc <- op(req.a, req.b)
}

服务端通过死循环来从 chan *Request 接收请求，为了避免长时间运行而导致阻塞，可以为每个请求都开一个 goroutine 来处理：

func server(op binOp, service chan *Request) {
    for {
        req := <-service; // requests arrive here
        // 为请求开一个 goroutine:
        go run(op, req);
        // 不用等待 op 结束
    }
}

使用 startServer 函数来启动服务的自有的协程（goroutine）：

func startServer(op binOp) chan *Request {
    reqChan := make(chan *Request);
    go server(op, reqChan);
    return reqChan;
}

startServer() 将会在 main() 主线程里被调用。

在下面的例子中，我们发送 100 个请求，并在所有请求发送完毕后，再逐个检查其返回的结果：

func main() {
    adder := startServer(func(a, b int) int { return a + b })
    const N = 100
    var reqs [N]Request
    for i := 0; i < N; i++ {
        req := &reqs[i]
        req.a = i
        req.b = i + N
        req.replyc = make(chan int)
        adder <- req
        // adder is a channel of requests
    }
    // checks:
    for i := N - 1; i >= 0; i-- { // doesn’t matter what order
        if <-reqs[i].replyc != N+2*i {
            fmt.Println(“fail at”, i)
            } else {
                fmt.Println(“Request “, i, “is ok!”)
        }
    }
    fmt.Println(“done”)
}

完整的代码请见 14.13 — multiplex_server.go（见文末），输出结果为：

Request 99 is ok!
Request 98 is ok!
…
Request 1 is ok!
Request 0 is ok!
Done

这个程序只开启 100 个 Goroutines 。执行 100000 个 Goroutines 的程序，甚至可以看到它在几秒钟内完成。这说明了 Goroutines 是有多么的轻量：如果我们启动相同数量的实际线程，程序将很快崩溃。

程序 14.14—multiplex_server.go:

package main
import "fmt"
type Request struct {
    a, b   int
    replyc chan int // 请求中的回复频道
}
type binOp func(a, b int) int
func run(op binOp, req *Request) {
    req.replyc <- op(req.a, req.b)
}
func server(op binOp, service chan *Request) {
    for {
        req := <-service // 请求到达这里
        // 开启请求的 Goroutine ：
        go run(op, req) // 不要等待 op
    }
}
func startServer(op binOp) chan *Request {
    reqChan := make(chan *Request)
    go server(op, reqChan)
    return reqChan
}
func main() {
    adder := startServer(func(a, b int) int { return a + b })
    const N = 100
    var reqs [N]Request
    for i := 0; i < N; i++ {
        req := &reqs[i]
        req.a = i
        req.b = i + N
        req.replyc = make(chan int)
        adder <- req
    }
    // 校验：
    for i := N - 1; i >= 0; i-- { // 顺序无所谓
        if <-reqs[i].replyc != N+2*i {
            fmt.Println("fail at", i)
        } else {
            fmt.Println("Request ", i, "is ok!")
        }
    }
    fmt.Println("done")
}

14.10.2 拆解：通过发信号通知关闭服务器

在以前的版本中，服务器在主返回时并不会被干净的关闭；它被强制停止。为了改善这一点，我们可以向服务器提供第二个退出通道：

func startServer(op binOp) (service chan *Request, quit chan bool) {
    service = make(chan *Request)
    quit = make(chan bool)
    go server(op, service, quit)
    return service, quit
}

server 函数使用 select 在服务通道和退出通道之间进行选择：

func server(op binOp, service chan *Request, quit chan bool) {
    for {
        select {
            case req := <-service:
            go run(op, req)
            case <-quit:
            return
        }
    }
}

当 真 值进入退出通道时，服务器返回并终止。

主要我们改变下面一行：

adder, quit := startServer(func(a, b int) int { return a + b })

在主要结尾处，我们放置该行：

quit <- true

完整的代码可以在 multiplex_server2.go 中找到，具有相同的输出：

练习 14.13：multiplex_server3.go：使用前面的例子，在 Request 结构中写入一个带有 String() 方法的变体，以便输出服务器；用 2 个请求测试程序：

req1 := &Request{3, 4, make(chan int)}
req2 := &Request{150, 250, make(chan int)}
…
// show the output:
fmt.Println(req1,"\n",req2)