如何在两个 goroutine 之间共享一个 HTTP 请求实例？

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《如何在两个 goroutine 之间共享一个 HTTP 请求实例？》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

我现在有一些代码可以发出 3 个请求来填充 3 个变量。两个请求是相同的。我想在两个不同的函数之间共享一个http请求（在现实世界中，这些函数被分成两个不同的模块）。

让我根据比现实世界中简单得多的示例来描述我所遇到的问题。

目前，我有以下主要功能和 post 数据结构：

type post struct {
    id          int    `json:"id"`
    title       string `json:"title"`
    userid      int    `json:"userid"`
    iscompleted bool   `json:"completed"`
}

func main() {
    var wg sync.waitgroup

    fmt.println("hello, world.")

    wg.add(3)

    var firstpostid int
    var secondpostid int
    var secondpostname string

    go func() {
        firstpostid = getfirstpostid()
        defer wg.done()
    }()

    go func() {
        secondpostid = getsecondpostid()
        defer wg.done()
    }()

    go func() {
        secondpostname = getsecondpostname()
        defer wg.done()
    }()

    wg.wait()

    fmt.println("first post id is", firstpostid)
    fmt.println("second post id is", secondpostid)
    fmt.println("second post title is", secondpostname)
}

有 3 个 goroutine，所以我有 3 个并发请求，我使用 sync.workgroup 同步所有内容。以下代码是请求的实现：

func makerequest(url string) post {
    resp, err := http.get(url)
    if err != nil {
        // handle error
    }
    defer resp.body.close()
    body, err := ioutil.readall(resp.body)
    var post post

    json.unmarshal(body, &post)

    return post
}

func makefirstpostrequest() post {
    return makerequest("https://jsonplaceholder.typicode.com/todos/1")
}

func makesecondpostrequest() post {
    return makerequest("https://jsonplaceholder.typicode.com/todos/2")
}

以下是从获取的帖子中提取所需信息的函数的实现：

func getfirstpostid() int {
    var result = makefirstpostrequest()
    return result.id
}

func getsecondpostid() int {
    var result = makesecondpostrequest()

    return result.id
}

func getsecondpostname() string {
    var result = makesecondpostrequest()

    return result.title
}

所以，目前我有 3 个并发请求，这工作得很好。问题是我不希望 2 个完全相同的单独 http 请求来获取第二篇文章。一个就足够了。所以，我想要实现的是 post 1 和 post 2 的 2 个并发请求。我希望第二次调用 makesecondpostrequest 不是创建新的 http 请求，而是共享现有的请求（由第一次调用发送）。

我怎样才能实现这个目标？

注意：例如，以下代码是如何使用 javascript 来完成此操作的。

let promise = null;
function makeRequest() {
    if (promise) {
        return promise;
    }

    return promise = fetch('https://jsonplaceholder.typicode.com/todos/1')
      .then(result => result.json())
      // clean up cache variable, so any next request in the future will be performed again
      .finally(() => (promise = null))

}

function main() {
    makeRequest().then((post) => {
        console.log(post.id);
    });
    makeRequest().then((post) => {
        console.log(post.title);
    });
}

main();

解决方案

虽然您可以将诸如 promise 之类的东西放在一起，但在这种情况下没有必要。

您的代码是以过程方式编写的。您已经编写了非常具体的函数，这些函数从 post 中提取特定的小部分并丢弃其余部分。相反，请将您的 post 放在一起。

package main

import(
    "fmt"
    "encoding/json"
    "net/http"
    "sync"
)

type post struct {
    id          int    `json:"id"`
    title       string `json:"title"`
    userid      int    `json:"userid"`
    iscompleted bool   `json:"completed"`
}

func fetchpost(id int) post {
    url := fmt.sprintf("https://jsonplaceholder.typicode.com/todos/%v", id)
    resp, err := http.get(url)
    if err != nil {
        panic("http error")
    }
    defer resp.body.close()

    // it's more efficient to let json decoder handle the io.
    var post post
    decoder := json.newdecoder(resp.body)
    err = decoder.decode(&post)
    if err != nil {
        panic("decoding error")
    }

    return post
}

func main() {
    var wg sync.waitgroup

    wg.add(2)

    var firstpost post
    var secondpost post

    go func() {
        firstpost = fetchpost(1)
        defer wg.done()
    }()

    go func() {
        secondpost = fetchpost(2)
        defer wg.done()
    }()

    wg.wait()

    fmt.println("first post id is", firstpost.id)
    fmt.println("second post id is", secondpost.id)
    fmt.println("second post title is", secondpost.title)
}

现在您可以缓存帖子，而不是缓存响应。我们可以通过添加 postmanager 来处理获取和缓存帖子来做到这一点。

请注意，普通的 map 对于并发使用并不安全，因此我们使用 sync.Map 作为缓存。

type postmanager struct {
    sync.map
}

func (pc *postmanager) fetch(id int) post {
    post, ok := pc.load(id)
    if ok {
        return post.(post)
    }
    post = pc.fetchpost(id)
    pc.store(id, post)

    return post.(post)
}

func (pc *postmanager) fetchpost(id int) post {    
    url := fmt.sprintf("https://jsonplaceholder.typicode.com/todos/%v", id)
    resp, err := http.get(url)
    if err != nil {
        panic("http error")
    }
    defer resp.body.close()

    // it's more efficient to let json decoder handle the io.
    var post post
    decoder := json.newdecoder(resp.body)
    err = decoder.decode(&post)
    if err != nil {
        panic("decoding error")
    }

    return post
}

postmanager 方法必须采用指针接收器以避免复制 sync.map 内的互斥体。

我们使用 postmanager，而不是直接获取帖子。

func main() {
    var postmanager postmanager

    var wg sync.waitgroup

    wg.add(2)

    var firstpost post
    var secondpost post

    go func() {
        firstpost = postmanager.fetch(1)
        defer wg.done()
    }()

    go func() {
        secondpost = postmanager.fetch(2)
        defer wg.done()
    }()

    wg.wait()

    fmt.println("first post id is", firstpost.id)
    fmt.println("second post id is", secondpost.id)
    fmt.println("second post title is", secondpost.title)
}

通过使用 conditional requests 检查缓存的 post 是否已更改，可以改进 postmanager 的缓存。

它的锁定也可以得到改进，因为可以同时获取同一篇文章。我们可以使用 singleflight 修复此问题，以允许一次仅对具有给定 id 的 fetchpost 进行一次调用。

type PostManager struct {
    group singleflight.Group
    cached sync.Map
}

func (pc *PostManager) Fetch(id int) Post {
    post,ok := pc.cached.Load(id)
    if !ok {
        // Multiple calls with the same key at the same time will only run the code once, but all calls get the result.
        post, _, _ = pc.group.Do(strconv.Itoa(id), func() (interface{}, error) {
            post := pc.fetchPost(id)
            pc.cached.Store(id, post)
            return post, nil
        })
    }
    return post.(Post)
}

好了，本文到此结束，带大家了解了《如何在两个 goroutine 之间共享一个 HTTP 请求实例？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！