Go 入门指南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)本译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 CC 协议，如果我们的工作有侵犯到您的权益，请及时联系我们。
关于 LearnKu
粤公网安备 44030502004330号
推荐文章：