《The Go 编程语言》一书中的 goroutine 泄漏示例

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《《The Go 编程语言》一书中的 goroutine 泄漏示例》，涉及到，有需要的可以收藏一下

我正在阅读《go 编程语言》一书，书中有一个演示 goroutine 泄漏的示例

func mirroredquery() string {
    responses := make(chan string, 3)
    go func() { responses <- request("asia.gopl.io") }()
    go func() { responses <- request("europe.gopl.io") }()
    go func() { responses <- request("americas.gopl.io") }()
    return <-responses // return the quickest response
}
func request(hostname string) (response string) { /* ... */ }

我尝试解决泄漏问题，并得到以下代码

func request(url string) string {
    res, err := http.Get(url)
    if err == nil {
        body, err := io.ReadAll(res.Body)
        if err == nil {
            return string(body)
        } else {
            return err.Error()
        }
    } else {
        return err.Error()
    }
}

func getany() string {
    rsp := make(chan string, 3)
    done := make(chan struct{}, 3)
    doRequest := func(url string) {
        select {
            case rsp <- request(url):
                fmt.Printf("get %s\n", url)
                done <- struct{}{}
            case <- done:
                fmt.Printf("stop %s\n", url)
                return
        }
    }
    go doRequest("http://google.com")
    go doRequest("http://qq.com")
    go doRequest("http://baidu.com")
    return <-rsp
}

但是好像并没有解决问题？有什么建议吗？

正确答案

所提供的代码中没有 goroutine 泄漏。 mirroredquery 方法使用缓冲通道来收集结果并返回第一个答案。当前缓冲区有足够的空间来收集所有 goroutine 的所有答案，即使其余响应从未被读取。如果缓冲区小于 n - 1，情况就会改变，其中 n 是生成的 goroutines 的数量。在这种情况下，由 mirroredquery 生成的一些 goroutine 在尝试向 responses 通道发送响应时会被卡住。重复调用 mirroredquery 会导致卡住的 goroutine 增加，这称为 goroutine leak。

以下是添加了日志的代码以及两种情况的输出。

func mirroredquery() string {
    responses := make(chan string, 2)
    go func() {
        responses <- request("asia.gopl.io")
        log.printf("finished goroutine asia.gopl.io\n")
    }()
    go func() {
        responses <- request("europe.gopl.io")
        log.printf("finished goroutine europe.gopl.io\n")
    }()
    go func() {
        responses <- request("americas.gopl.io")
        log.printf("finished goroutine americas.gopl.io\n")
    }()
    return <-responses // return the quickest response
}
func request(hostname string) (response string) {
    duration := time.duration(rand.int63n(5000)) * time.millisecond
    time.sleep(duration)
    return hostname
}

func main() {
    rand.seed(time.now().unixnano())
    result := mirroredquery()
    log.printf("fastest result for %s\n", result)
    time.sleep(6*time.second)
}

缓冲区大小 >= n-1 的输出

2021/06/26 16:05:27 finished europe.gopl.io
2021/06/26 16:05:27 fastest result for europe.gopl.io
2021/06/26 16:05:28 finished asia.gopl.io
2021/06/26 16:05:30 finished americas.gopl.io

process finished with the exit code 0

缓冲区大小 < n-1 的输出

2021/06/26 15:47:54 finished europe.gopl.io
2021/06/26 15:47:54 fastest result for europe.gopl.io

process finished with the exit code 0

可以通过在第一个响应到达时引入 goroutine 终止来“改进”上述实现。这可能会减少使用的资源数量。它很大程度上取决于 request 方法的作用。对于计算量大的场景，这是有意义的，因为取消 http 请求可能会导致连接终止，因此下一个请求必须打开新的请求。对于高负载的服务器，即使不使用响应，它也可能不如等待响应有效。

下面是使用 context 的改进实现。

func mirroredquery() string {
    ctx, cancel := context.withcancel(context.background())
    defer cancel()
    responses := make(chan string)
    f := func(hostname string) {
        response, err := request(ctx, hostname)
        if err != nil {
            log.printf("finished %s with error %s\n", hostname, err)
            return
        }
        responses <- response
        log.printf("finished %s\n", hostname)
    }
    go f("asia.gopl.io")
    go f("europe.gopl.io")
    go f("americas.gopl.io")
    return <-responses // return the quickest response
}

func request(ctx context.context, hostname string) (string, error) {
    duration := time.duration(rand.int63n(5000)) * time.millisecond
    after := time.after(duration)
    select {
    case <-ctx.done():
        return "", ctx.err()
    case <-after:
        return "response for "+hostname, nil
    }
}

func main() {
    rand.seed(time.now().unixnano())
    result := mirroredquery()
    log.printf("fastest result for %s\n", result)
    time.sleep(6 * time.second)
}

你看错书了。本书使用示例来说明如何使用缓冲通道来避免 goroutine 泄漏。

这是紧接着书中示例的段落（第 233 页）：

注意：

1. 此函数不会尝试优化内存占用或资源使用（包括网络资源）。 go 的 net/http 包的客户端函数是上下文感知的，因此它可以在请求中间取消，这将节省一些资源（是否会造成麻烦取决于设计决策）。

要使用上下文，您可以：

func mirroredquery() string {
    responses := make(chan string, 3)
    ctx, cf := context.withcancel(context.background())
    defer cf()

    go func() { responses <- request("asia.gopl.io") }()
    go func() { responses <- request("europe.gopl.io") }()
    go func() { responses <- request("americas.gopl.io") }()
    return <-responses // return the quickest response
}

func request(ctx context.context, url string) string {
    req, err := http.newrequestwithcontext(ctx, http.methodget, url, nil)
    if err != nil {
        panic(err)
    }
    res, err := http.defaultclient.do(req)
    if err == nil {
        body, err := io.readall(res.body)
        if err == nil {
            return string(body)
        } else {
            return err.error()
        }
    } else {
        return err.error()
    }
}

1. 使用缓冲通道分配内存。当 goroutine 太多时，使用缓冲通道就太浪费了。

要解决此问题，您可以使用通道（就像您尝试的那样）：

func getany() string {
    responses := make(chan string)
    ctx, cf := context.withcancel(context.background())
    defer cf()
    done := make(chan struct{})
    defer close(done)

    dorequest := func(url string) {
        select {
        case responses <- request(ctx, url):
            fmt.printf("get %s\n", url)
        case <-done:
            fmt.printf("stop %s\n", url)
            return
        }
    }

    go dorequest("http://google.com")
    go dorequest("http://qq.com")
    go dorequest("http://baidu.com")
    return <-responses // return the quickest response
}

在关闭的通道上接收总是立即“返回”零值，因此充当广播。使用这种“完成通道”是常见的做法。

您还可以使用 context.context：

func mirroredQuery() string {
    responses := make(chan string)
    ctx, cf := context.WithCancel(context.Background())
    defer cf()

    doRequest := func(url string) {
        select {
        case responses <- request(ctx, url):
            fmt.Printf("get %s\n", url)
        case <-ctx.Done():
            fmt.Printf("stop %s\n", url)
            return
        }
    }

    go doRequest("http://google.com")
    go doRequest("http://qq.com")
    go doRequest("http://baidu.com")
    return <-responses // return the quickest response
}

在这种情况下效果更好，因为您已经使用了带有 http 的 context.context。

1. 使用 sync.workgroup 将等待所有请求完成，但返回第一个请求。我认为这违背了该功能的目的，并且几乎没有提供任何好处。而且我认为让函数生成的所有 goroutine 在函数本身返回之前返回是没有意义的（除非该函数是主函数）。

好了，本文到此结束，带大家了解了《《The Go 编程语言》一书中的 goroutine 泄漏示例》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！