高效GO语言编程（12）——并发（中）

UnknownFlower

已于 2022-01-22 12:08:27 修改

阅读量99

点赞数

分类专栏： GO语言文章标签： golang 开发语言后端并发

于 2022-01-22 12:08:18 首次发布

原文链接：https://www.golangroadmap.com/books/effectivego/13.html#%E4%BF%A1%E9%81%93

版权

GO语言专栏收录该内容

39 篇文章 2 订阅

订阅专栏

欢迎加入GolangRoadmap，一个年轻的GO开发者社区https://www.golangroadmap.com/，目前是邀请制注册，注册码：Gopher-1035-0722，已开放GO内推，GO面试，GO宝典，GO学院，GO友会等栏目

信道

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

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

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

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

c := make(chan int)  // 创建一个无缓冲的类型为整型的 channel 。
//用 goroutine 开始排序；当它完成时，会在信道上发信号。
go func() {
    list.Sort()
    c <- 1  // 发送一个信号，这个值并没有具体意义
}()
doSomethingForAWhile()
<-c   // 等待 sort 执行完成，然后从 channel 取值

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

带缓冲的信道可被用作信号量，例如限制吞吐量。在此例中，进入的请求会被传递给 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 结束。
    }
}

一旦有MaxOutstanding个处理程序正在执行 process，缓冲区已满的信道的操作都暂停接收更多操作，直到至少一个程序完成并从缓冲区接收。

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

func Serve(queue chan *Request) {
    for req := range queue {
        sem <- 1
        go func() {
            process(req) // Buggy; see explanation below.
            <-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  // 等待通知退出。
}