【Go】優雅的讀取 http 請求或響應的資料-續

qiyin發表於2019-02-01

原文連結：https://blog.thinkeridea.com/...

之前釋出【Go】優雅的讀取 http 請求或響應的資料文章，網友 “wxe” 諮詢：“優化前後的請求耗時變化有多大”，之前只分析了記憶體分配，這篇文章用單元測試的方式分析優化前後的耗時情況，本文原始碼。

非常感謝 “wxe” 網友的提問，讓我在測試過程中發現一個 json 序列化的問題。

之前我們優化了兩個部分，json 與 ioutil.ReadAll，先對比 ioutil.ReadAll, 這裡測試的程式碼分成兩個部分做對比，一部分單純對比 ioutil.ReadAll 和 io.Copy + sync.Pool，另一部分增加 jsoniter.Unmarshal 來延遲 pool.Put(buffer) 的執行, 原始碼。

package iouitl_readall

import (
    "bytes"
    "io"
    "io/ioutil"
    "sync"

    jsoniter "github.com/json-iterator/go"
)

var pool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 4096))
    },
}

func IoCopyAndJson(r io.Reader) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    res := Do(r)
    _, err := io.Copy(buffer, res)
    if err != nil {
        return err
    }

    m := map[string]string{}
    err = jsoniter.Unmarshal(buffer.Bytes(), &m)
    return err
}

func IouitlReadAllAndJson(r io.Reader) error {
    res := Do(r)
    data, err := ioutil.ReadAll(res)
    if err != nil {
        return err
    }

    m := map[string]string{}
    err = jsoniter.Unmarshal(data, &m)
    return err
}

func IoCopy(r io.Reader) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    res := Do(r)
    _, err := io.Copy(buffer, res)
    if err != nil {
        return err
    }

    return err
}

func IouitlReadAll(r io.Reader) error {
    res := Do(r)
    data, err := ioutil.ReadAll(res)
    if err != nil {
        return err
    }
    _ = data
    return err
}

測試程式碼如下原始碼:

package iouitl_readall

import (
    "bytes"
    "testing"
)

var data = bytes.Repeat([]byte("ABCD"), 1000)

func BenchmarkIouitlReadAll(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IouitlReadAll(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkIoCopy(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IoCopy(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkIouitlReadAllAndJson(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IouitlReadAllAndJson(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkIoCopyAndJson(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IoCopyAndJson(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

測試結果如下:

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/example/iouitl_readall
BenchmarkIouitlReadAll-8                500000          2752 ns/op       14496 B/op           6 allocs/op
BenchmarkIoCopy-8                     20000000            65.2 ns/op          48 B/op           1 allocs/op
BenchmarkIouitlReadAllAndJson-8         100000         20022 ns/op       46542 B/op         616 allocs/op
BenchmarkIoCopyAndJson-8                100000         17615 ns/op       32102 B/op         611 allocs/op

結論：

可以發現 IoCopy 方法是 IouitlReadAll 方法效率的 40 倍，記憶體分配也很少，而 IoCopyAndJson 和 IouitlReadAllAndJson 的效率差異極小僅有 2407ns，大約是 1.13 倍，不過記憶體分配還是少了很多的，為什麼會這樣呢，這就是 sync.Pool 的導致的，sync.Pool 每次獲取使用時間越短，命中率就越高，就可以減少建立新的快取，這樣效率就會大大提高，而 jsoniter.Unmarshal 很耗時，就導致 sync.Pool 的命中率降低了，所以效能下降極其明顯.

使用 io.Copy + sync.Pool 表面上執行效率不會有很大提升，但是會大幅度減少記憶體分配，從而可以減少 GC 的負擔，在單元測試中我們並沒有考慮 GC 的問題，而 GC 能帶來的效能提升會更有優勢。

在看一下 json 使用 sync.Pool 的效果吧原始碼

package iouitl_readall

import (
    "bytes"
    "encoding/json"

    jsoniter "github.com/json-iterator/go"
)

func Json(r map[string]string) error {
    data, err := json.Marshal(r)
    if err != nil {
        return err
    }

    _ = data
    return nil
}

func JsonPool(r map[string]string) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    e := json.NewEncoder(buffer)
    err := e.Encode(r)
    if err != nil {
        return err
    }

    return nil
}

func JsonIter(r map[string]string) error {
    data, err := jsoniter.Marshal(r)
    if err != nil {
        return err
    }

    _ = data
    return nil
}

func JsonIterPool(r map[string]string) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    e := jsoniter.NewEncoder(buffer)
    err := e.Encode(r)
    if err != nil {
        return err
    }

    return nil
}

效能測試程式碼原始碼:

package iouitl_readall

import (
    "strconv"
    "strings"
    "testing"
)

var request map[string]string

func init() {
    request = make(map[string]string, 100)
    for i := 0; i < 100; i++ {
        request["X"+strconv.Itoa(i)] = strings.Repeat("A", i/2)
    }
}
func BenchmarkJson(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := Json(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkJsonIter(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := JsonIter(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkJsonPool(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := JsonPool(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkJsonIterPool(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := JsonIterPool(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

測試結果如下:

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/example/iouitl_readall
BenchmarkJson-8                         100000         13297 ns/op       13669 B/op         207 allocs/op
BenchmarkJsonPool-8                     100000         13310 ns/op       10218 B/op         206 allocs/op
BenchmarkJsonIter-8                     500000          2948 ns/op        3594 B/op           4 allocs/op
BenchmarkJsonIterPool-8                 200000          6126 ns/op        6040 B/op         144 allocs/op
PASS
ok      github.com/thinkeridea/example/iouitl_readall    12.716s

這裡使用了兩個 json 包，一個是標準庫的，一個是 jsoniter (也是社群反饋效率最高的)，對比兩個包使用 sync.Pool 和不使用之間的差異，發現標準庫 json 包使用後記憶體有少量減少，但是執行效率稍微下降了，差異不是很大，jsoniter 包差異之所謂非常明顯，發現使用 sync.Pool 之後不僅記憶體分配更多了，執行效率也大幅度下降，差了將近 3 倍有餘。

是不是很奔潰，這是啥情況 jsoniter 本身就使用了 sync.Pool 作緩衝，我們使用 jsoniter.NewEncoder(buffer) 建立一個序列化例項，但是其內部並沒有直接使用 io.Writer 而是先使用緩衝序列化資料，之後寫入 io.Writer, 具體程式碼如下：

// Flush writes any buffered data to the underlying io.Writer.
func (stream *Stream) Flush() error {
    if stream.out == nil {
        return nil
    }
    if stream.Error != nil {
        return stream.Error
    }
    n, err := stream.out.Write(stream.buf)
    if err != nil {
        if stream.Error == nil {
            stream.Error = err
        }
        return err
    }
    stream.buf = stream.buf[n:]
    return nil
}

這樣一來我們使用 buffer 做 json 序列化優化效果就大打折扣，甚至適得其反了。

再次感謝 “wxe” 網友的提問，這裡沒有使用實際的應用場景做效能測試，主要發現在效能測試中使用 http 服務會導致 connect: can't assign requested address 問題，所以測試用使用了函式模擬，如果有朋友有更好的測試方法歡迎一起交流。

轉載：

本文作者：戚銀（thinkeridea）

本文連結： https://blog.thinkeridea.com/201902/go/you_ya_de_du_qu_http_qing_qiu_huo_xiang_ying_de_shu_ju_2.html

版權宣告：本部落格所有文章除特別宣告外，均採用 CC BY 4.0 CN 協議許可協議。轉載請註明出處！

更多原創文章乾貨分享，請關注公眾號

加微信實戰群請加微信(註明:實戰群)：gocnio

【Go】優雅的讀取http請求或響應的資料-續
2019-02-01
GoHTTP
【Go】優雅的讀取 http 請求或響應的資料
2019-01-26
GoHTTP
【Go】優雅的讀取http請求或響應的資料
2019-01-26
GoHTTP
Go如何響應http請求？
2019-04-03
GoHTTP
HTTP的請求與響應
2019-03-16
HTTP
HTTP 請求與響應
2018-12-05
HTTP
Http請求與響應
2018-04-08
HTTP
Flask中請求資料的優雅傳遞
2022-02-17
Flask
http請求頭與響應頭的應用
2018-09-10
HTTP
HTTP請求格式和HTTP響應格式
2018-07-25
HTTP
Spring MVC能響應HTTP請求的原因？
2018-08-29
SpringMVCHTTP
boost http響應讀取
2018-04-17
HTTP
HTTP請求頭與響應頭
2018-05-27
HTTP
HTTP請求與響應簡析
2019-04-19
HTTP
go http請求
2024-06-12
GoHTTP
Wireshark的HTTP請求包和響應包如何對應
2022-06-25
HTTP
Spring系列 SpringMVC的請求與資料響應
2020-10-15
SpringMVC
Springboot -- 用更優雅的方式發HTTP請求(RestTemplate詳解)
2018-08-31
Spring BootHTTPREST
使用Python獲取HTTP請求頭資料
2024-06-17
PythonHTTP
Qt - http網路請求與響應
2024-12-04
QTHTTP
OkHttp 原始碼剖析系列（七）——請求的發起及響應的讀取
2020-01-03
HTTP原始碼
如何優雅地讀寫HttpServletRequest和HttpServletResponse的請求體
2021-12-31
HTTPServlet
型別安全的 Go HTTP 請求
2022-05-23
型別GoHTTP
Jmeter 請求 websocket 獲得的響應資料不全
2020-06-12
JMeterWeb
HTTP的請求與響應以及使用Chrome的檢視方式
2019-02-04
HTTPChrome
完整的一次 HTTP 請求響應過程（二）
2019-03-02
HTTP
完整的一次 HTTP 請求響應過程（一）
2018-06-01
HTTP
指令碼化HTTP 取得響應指定請求
2018-08-15
指令碼HTTP
HTTP請求頭和響應頭詳解
2020-10-14
HTTP
Http請求資料格式
2019-02-16
HTTP
curl 請求獲取響應時間
2020-11-17
SAP UI5 應用讀取 CSRF token 的 HTTP head 請求邏輯解析
2022-02-16
UIHTTP
HttpClient入門（1）傳送請求，處理響應及響應重複讀取
2018-03-28
HTTPclient
go搞笑http請求庫
2024-05-12
GoHTTP
go http請求流程分析
2020-09-11
GoHTTP
關於常用的http請求頭以及響應頭詳解
2018-12-21
HTTP
HTTP請求的快取（Cache）機制
2019-05-24
HTTP快取
基於tcp的http應用，斷點續傳，範圍請求
2018-08-03
TCPHTTP斷點

【Go】優雅的讀取 http 請求或響應的資料-續

相關文章