【Go】优雅的读取http请求或响应的数据-续

thinkeridea · · 223 次点击 · 开始浏览    置顶
原文链接:https://blog.thinkeridea.com/201902/go/you_ya_de_du_qu_http_qing_qiu_huo_xiang_ying_de_shu_ju_2.html 之前发布 [【Go】优雅的读取http请求或响应的数据](https://blog.thinkeridea.com/201901/go/you_ya_de_du_qu_http_qing_qiu_huo_xiang_ying_de_shu_ju.html) 文章,网友 “wxe” 咨询:“优化前后的请求耗时变化有多大”,之前只分析了内存分配,这篇文章用单元测试的方式分析优化前后的耗时情况,[本文源码](https://github.com/thinkeridea/example/tree/master/iouitl_readall)。 非常感谢 “wxe” 网友的提问,让我在测试过程中发现一个 `json` 序列化的问题。 之前我们优化了两个部分,`json` 与 `ioutil.ReadAll`, 先对比 `ioutil.ReadAll`, 这里测试的代码分成两个部分做对比,一部分单纯对比 `ioutil.ReadAll` 和 `io.Copy` + `sync.Pool`,另一部分增加 `jsoniter.Unmarshal` 来延迟 `pool.Put(buffer)` 的执行, [源码](https://github.com/thinkeridea/example/blob/master/iouitl_readall/io.go)。 ```go 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 } ``` 测试代码如下[源码](https://github.com/thinkeridea/example/blob/master/iouitl_readall/io_test.go): ```go 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` 的效果吧 [源码](https://github.com/thinkeridea/example/blob/master/iouitl_readall/json.go) ```go 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 } ``` 性能测试代码[源码](https://github.com/thinkeridea/example/blob/master/iouitl_readall/json_test.go): ```go 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`, 具体代码如下: ```go // 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/))** **本文链接: [https://blog.thinkeridea.com/201902/go/you_ya_de_du_qu_http_qing_qiu_huo_xiang_ying_de_shu_ju_2.html](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协议](http://creativecommons.org/licenses/by/4.0/deed.zh) 许可协议。转载请注明出处!**
223 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传