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

時間  2019-11-06
標籤 優雅 讀取 http 請求 響應 數據 欄目 Go 简体版
原文   原文鏈接

原文連接： blog.thinkeridea.com/201902/go/y…html

以前發佈 【Go】優雅的讀取http請求或響應的數據 文章，網友 「wxe」 諮詢：「優化先後的請求耗時變化有多大」，以前只分析了內存分配，這篇文章用單元測試的方式分析優化先後的耗時狀況，本文源碼。git

很是感謝 「wxe」 網友的提問，讓我在測試過程當中發現一個 json 序列化的問題。github

以前咱們優化了兩個部分，json 與 ioutil.ReadAll， 先對比 ioutil.ReadAll, 這裏測試的代碼分紅兩個部分作對比，一部分單純對比 ioutil.ReadAll 和 io.Copy + sync.Pool，另外一部分增長 jsoniter.Unmarshal 來延遲 pool.Put(buffer) 的執行, 源碼。json

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())
			}
		}
	})
}
複製代碼

測試結果以下:ide

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）

本文連接： blog.thinkeridea.com/201902/go/y…

版權聲明： 本博客全部文章除特別聲明外，均採用 CC BY 4.0 CN協議 許可協議。轉載請註明出處！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程