for-loop 與 json.Unmarshal 性能分析概要

時間  2019-11-08
標籤 loop json.unmarshal json unmarshal 性能 分析 概要 欄目 JavaScript 简体版
原文   原文鏈接

原文地址：for-loop 與 json.Unmarshal 性能分析概要html

前言

在項目中，經常會遇到循環交換賦值的數據處理場景，尤爲是 RPC，數據交互格式要轉爲 Protobuf，賦值是沒法避免的。通常會有以下幾種作法：git

  • for
  • for range
  • json.Marshal/Unmarshal

這時候又面臨 「選擇困難症」，用哪一個好？又想代碼量少，又擔憂性能有沒有影響啊...github

爲了弄清楚這個疑惑，接下來將分別編寫三種使用場景。來簡單看看它們的性能狀況，看看誰更 「好」golang

功能代碼

...
type Person struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Avatar string `json:"avatar"`
    Type   string `json:"type"`
}

type AgainPerson struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Avatar string `json:"avatar"`
    Type   string `json:"type"`
}

const MAX = 10000

func InitPerson() []Person {
    var persons []Person
    for i := 0; i < MAX; i++ {
        persons = append(persons, Person{
            Name:   "EDDYCJY",
            Age:    i,
            Avatar: "https://github.com/EDDYCJY",
            Type:   "Person",
        })
    }

    return persons
}

func ForStruct(p []Person, count int) {
    for i := 0; i < count; i++ {
        _, _ = i, p[i]
    }
}

func ForRangeStruct(p []Person) {
    for i, v := range p {
        _, _ = i, v
    }
}

func JsonToStruct(data []byte, againPerson []AgainPerson) ([]AgainPerson, error) {
    err := json.Unmarshal(data, &againPerson)
    return againPerson, err
}

func JsonIteratorToStruct(data []byte, againPerson []AgainPerson) ([]AgainPerson, error) {
    var jsonIter = jsoniter.ConfigCompatibleWithStandardLibrary
    err := jsonIter.Unmarshal(data, &againPerson)
    return againPerson, err
}

測試代碼

...
func BenchmarkForStruct(b *testing.B) {
    person := InitPerson()
    count := len(person)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ForStruct(person, count)
    }
}

func BenchmarkForRangeStruct(b *testing.B) {
    person := InitPerson()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ForRangeStruct(person)
    }
}

func BenchmarkJsonToStruct(b *testing.B) {
    var (
        person = InitPerson()
        againPersons []AgainPerson
    )
    data, err := json.Marshal(person)
    if err != nil {
        b.Fatalf("json.Marshal err: %v", err)
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        JsonToStruct(data, againPersons)
    }
}

func BenchmarkJsonIteratorToStruct(b *testing.B) {
    var (
        person = InitPerson()
        againPersons []AgainPerson
    )
    data, err := json.Marshal(person)
    if err != nil {
        b.Fatalf("json.Marshal err: %v", err)
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        JsonIteratorToStruct(data, againPersons)
    }
}

測試結果

BenchmarkForStruct-4                    500000          3289 ns/op           0 B/op           0 allocs/op
BenchmarkForRangeStruct-4               200000          9178 ns/op           0 B/op           0 allocs/op
BenchmarkJsonToStruct-4                    100      19173117 ns/op     2618509 B/op       40036 allocs/op
BenchmarkJsonIteratorToStruct-4            300       4116491 ns/op     3694017 B/op       30047 allocs/op

從測試結果來看，性能排名爲：for < for range < json-iterator < encoding/json。接下來咱們看看是什麼緣由致使了這樣子的排名？json

性能對比

image

for-loop

在測試結果中，for range 在性能上相較 for 差。這是爲何呢？在這裏咱們能夠參見 for range 的 實現，僞實現以下：緩存

for_temp := range
len_temp := len(for_temp)
for index_temp = 0; index_temp < len_temp; index_temp++ {
    value_temp = for_temp[index_temp]
    index = index_temp
    value = value_temp
    original body
}

經過分析僞實現，可得知 for range 相較 for 多作了以下事項app

Expression

RangeClause = [ ExpressionList "=" | IdentifierList ":=" ] "range" Expression .

在循環開始以前會對範圍表達式進行求值，多作了 「解」 表達式的動做，獲得了最終的範圍值frontend

Copy

...
value_temp = for_temp[index_temp]
index = index_temp
value = value_temp
...

從僞實現上能夠得出，for range 始終使用值拷貝的方式來生成循環變量。通俗來說，就是在每次循環時，都會對循環變量從新分配oop

小結

經過上述的分析，可得知其比 for 慢的緣由是 for range 有額外的性能開銷，主要爲值拷貝的動做致使的性能降低。這是它慢的緣由性能

那麼其實在 for range 中，咱們可使用 _ 和 T[i] 也能達到和 for 差很少的性能。但這可能不是 for range 的設計本意了

json.Marshal/Unmarshal

encoding/json

json 互轉是在三種方案中最慢的，這是爲何呢？

衆所皆知，官方的 encoding/json 標準庫，是經過大量反射來實現的。那麼 「慢」，也是必然的。可參見下述代碼：

...
func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
    ...
    switch t.Kind() {
    case reflect.Bool:
        return boolEncoder
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return intEncoder
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
        return uintEncoder
    case reflect.Float32:
        return float32Encoder
    case reflect.Float64:
        return float64Encoder
    case reflect.String:
        return stringEncoder
    case reflect.Interface:
        return interfaceEncoder
    case reflect.Struct:
        return newStructEncoder(t)
    case reflect.Map:
        return newMapEncoder(t)
    case reflect.Slice:
        return newSliceEncoder(t)
    case reflect.Array:
        return newArrayEncoder(t)
    case reflect.Ptr:
        return newPtrEncoder(t)
    default:
        return unsupportedTypeEncoder
    }
}

既然官方的標準庫存在必定的 「問題」，那麼有沒有其餘解決方法呢？目前在社區裏，大多爲兩類方案。以下：

  • 預編譯生成代碼（提早肯定類型），能夠解決運行時的反射帶來的性能開銷。缺點是增長了預生成的步驟
  • 優化序列化的邏輯，性能達到最大化

接下來的實驗，咱們用第二種方案的庫來測試，看看有沒有改變。另外也推薦你們瞭解以下項目：

json-iterator/go

目前社區較經常使用的是 json-iterator/go，咱們在測試代碼中用到了它

它的用法與標準庫 100% 兼容，而且性能有較大提高。咱們一塊兒粗略的看下是怎麼作到的，以下：

reflect2

利用 modern-go/reflect2 減小運行時調度開銷

...
type StructDescriptor struct {
    Type   reflect2.Type
    Fields []*Binding
}

...
type Binding struct {
    levels    []int
    Field     reflect2.StructField
    FromNames []string
    ToNames   []string
    Encoder   ValEncoder
    Decoder   ValDecoder
}

type Extension interface {
    UpdateStructDescriptor(structDescriptor *StructDescriptor)
    CreateMapKeyDecoder(typ reflect2.Type) ValDecoder
    CreateMapKeyEncoder(typ reflect2.Type) ValEncoder
    CreateDecoder(typ reflect2.Type) ValDecoder
    CreateEncoder(typ reflect2.Type) ValEncoder
    DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder
    DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder
}
struct Encoder/Decoder Cache

類型爲 struct 時，只須要反射一次 Name 和 Type，會緩存 struct Encoder 和 Decoder

var typeDecoders = map[string]ValDecoder{}
var fieldDecoders = map[string]ValDecoder{}
var typeEncoders = map[string]ValEncoder{}
var fieldEncoders = map[string]ValEncoder{}
var extensions = []Extension{}

....

fieldNames := calcFieldNames(field.Name(), tagParts[0], tag)
fieldCacheKey := fmt.Sprintf("%s/%s", typ.String(), field.Name())
decoder := fieldDecoders[fieldCacheKey]
if decoder == nil {
    decoder = decoderOfType(ctx.append(field.Name()), field.Type())
}
encoder := fieldEncoders[fieldCacheKey]
if encoder == nil {
    encoder = encoderOfType(ctx.append(field.Name()), field.Type())
}
文本解析優化

小結

相較於官方標準庫，第三方庫 json-iterator/go 在運行時上作的更好。這是它快的緣由

有個須要注意的點，在 Go1.10 後 map 類型與標準庫的已經沒有太大的性能差別。可是，例如 struct 類型等仍然有較大的性能提升

總結

在本文中，咱們首先進行了性能測試，再分析了不一樣方案，得知爲何了快慢的緣由。那麼最終在選擇方案時，能夠根據不一樣的應用場景去抉擇：

  • 對性能開銷有較高要求：選用 for，開銷最小
  • 中規中矩：選用 for range，大對象慎用
  • 量小、佔用小、數量可控：選用 json.Marshal/Unmarshal 的方案也能夠。其重複代碼少，但開銷最大

在絕大多數場景中，使用哪一種並無太大的影響。但做爲工程師你應當清楚其利弊。以上就是不一樣的方案分析概要，但願對你有所幫助 :)

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