performance - golang json/gob/xml 中的序列化性能

Question

转到标准库，Json 序列化性能问题...JSON 比 XML 和 GOB 慢，而 json 大小小于 xml 文件大小？

请帮忙指出有什么错误吗？

docker@dockhost:~/go/projects/wiki$ go run encoding.go 
2016/05/24 00:52:16 Serialization by JSON elapsed: 2152195 us
2016/05/24 00:52:16 students.json 19177782
2016/05/24 00:52:17 Serialization by GOB elapsed: 748867 us
2016/05/24 00:52:17 students.gob 9305166
2016/05/24 00:52:18 Serialization by XML elapsed: 1507397 us
2016/05/24 00:52:18 students.xml 26177780

docker@dockhost:~/go/projects/wiki$ go run encoding.go 
2016/05/24 00:52:32 Serialization by JSON elapsed: 1388153 us
2016/05/24 00:52:32 students.json 19177782
2016/05/24 00:52:33 Serialization by GOB elapsed: 502814 us
2016/05/24 00:52:33 students.gob 9305166
2016/05/24 00:52:34 Serialization by XML elapsed: 897859 us
2016/05/24 00:52:34 students.xml 26177780

docker@dockhost:~/go/projects/wiki$ go run encoding.go 
2016/05/24 00:52:41 Serialization by JSON elapsed: 1290359 us
2016/05/24 00:52:41 students.json 19177782
2016/05/24 00:52:42 Serialization by GOB elapsed: 434203 us
2016/05/24 00:52:42 students.gob 9305166
2016/05/24 00:52:42 Serialization by XML elapsed: 862379 us
2016/05/24 00:52:42 students.xml 26177780

代码:

package main


import (
        "log"
        "encoding/json"
        "encoding/gob"
        "encoding/xml"
        "math/rand"
        "strconv"
        "os"
        "time"
)



const (
        Male=iota
        Female
        Unknown

        ALL=100000
)

type Person struct {
        Name string
        Id      string
        Age     int
        Gender  int
}
type Student struct {
        Person Person
        Grade int
        Class   string
        Teacher Person
}

func (s  Student) String() string{
        v,err:=json.Marshal(s)
        if err!=nil {
                log.Fatal("Marshal failed",s)
        }
        return string(v)

}

var students []Student
func init(){
        students=make([]Student,ALL)
        for i:=0;i<ALL;i++ {
                students[i].Grade=rand.Intn(5)
                students[i].Class=strconv.Itoa(students[i].Grade)+",class"+strconv.Itoa(rand.Intn(10))
                students[i].Person.Name="Student "+strconv.Itoa(i)
                students[i].Person.Id="11001234512345551"+strconv.Itoa(rand.Intn(10))
                students[i].Person.Age=10+rand.Intn(10)
                students[i].Person.Gender=rand.Intn(3)
                students[i].Teacher.Id="22001154365151344"+strconv.Itoa(rand.Intn(10))
                students[i].Teacher.Name="Teacher "+strconv.Itoa(i)
                students[i].Teacher.Age=40+rand.Intn(10)
                students[i].Teacher.Gender=rand.Intn(3)
        }

}

func toJsonFile(){
        f,err:=os.OpenFile("students.json",os.O_RDWR ,0600)
        if err!=nil {
                log.Fatal("Can't open students.json "+ err.Error())
        }
        defer f.Close()
        en:=json.NewEncoder(f)
        err=en.Encode(students)
        if err!=nil {

                log.Fatal(err)
        }

}

func loadJsonFile(){
        f,err:=os.Open("students.json")
        if err!=nil {
                log.Fatal(err)
        }
        defer f.Close()
        dec:=json.NewDecoder(f)
        ss:=make([]Student,ALL)
        err=dec.Decode(&ss)
        if err!=nil {

                log.Fatal(err)
        }
//      log.Println(ss)
}



func toGobFile(){
        f,err:=os.OpenFile("students.gob",os.O_RDWR ,0600)
        if err!=nil {
                log.Fatal("Can't open students.gob "+ err.Error())
        }
        defer f.Close()
        en:=gob.NewEncoder(f)
        err=en.Encode(students)
        if err!=nil {

                log.Fatal(err)
        }

}

func loadGobFile(){
        f,err:=os.Open("students.gob")
        if err!=nil {
                log.Fatal(err)
        }
        defer f.Close()
        dec:=gob.NewDecoder(f)
        ss:=make([]Student,ALL)
        err=dec.Decode(&ss)
        if err!=nil {

                log.Fatal(err)
        }
//      log.Println(ss)
}



func toXmlFile(){
        f,err:=os.OpenFile("students.xml",os.O_RDWR ,0600)
        if err!=nil {
                log.Fatal( err.Error())
        }
        defer f.Close()
        en:=xml.NewEncoder(f)
        err=en.Encode(students)
        if err!=nil {

                log.Fatal(err)
        }

}
func loadXmlFile(){
        f,err:=os.Open("students.xml")
        if err!=nil {
                log.Fatal(err)
        }
        defer f.Close()
        dec:=xml.NewDecoder(f)
        ss:=make([]Student,ALL)
        err=dec.Decode(&ss)
        if err!=nil {

                log.Fatal(err)
        }
//      log.Println(ss)
}




func main(){
        start:=time.Now()
        toJsonFile()
        loadJsonFile()
        end:=time.Now()

        log.Printf("Serialization by JSON elapsed: %d us",end.Sub(start)/1000)

        fi,err:=os.Stat("students.json")
        if err!=nil {
                log.Fatal(err)
        }
        log.Println(fi.Name(), fi.Size())



        start=time.Now()
        toGobFile()
        loadGobFile()
        end=time.Now()


        log.Printf("Serialization by GOB elapsed: %d us",end.Sub(start)/1000)

        fi,err=os.Stat("students.gob")
        if err!=nil {
                log.Fatal(err)
        }
        log.Println(fi.Name(), fi.Size())

        start=time.Now()
        toXmlFile()
        loadXmlFile()
        end=time.Now()


        log.Printf("Serialization by XML elapsed: %d us",end.Sub(start)/1000)

        fi,err=os.Stat("students.xml")
        if err!=nil {
                log.Fatal(err)
        }
        log.Println(fi.Name(), fi.Size())

}

Answer 1

正如您报告的那样，您的基准测试具有很多运行间变异性。这使得很难对问题进行推理。我们真正想要的是一个始终给出相同结果的基准，无论我们在一天中的什么时间运行它。

我稍微修改了你的基准，以便更容易可靠地重现结果:1. 我将数据序列化到内存中(作为字节 slice []byte)，2. 我避免数据溢出处理器的缓存(即，使用少量数据)。

有一种在 Go 中编写基准测试的标准方法，以获得更多可重现的结果 (https://dave.cheney.net/2013/06/30/how-to-write-benchmarks-in-go)，但在这种情况下，我认为没有必要。

在 https://github.com/lemire/Code-used-on-Daniel-Lemire-s-blog/tree/master/extra/golang/serialization 查看我的代码

在我的测试服务器上(为测试配置的 Skylake 处理器，以 3.4 GHz 的平坦频率运行，go 1.7)，我得到...


2016/12/22 09:55:54 JSON 序列化耗时:599 us
2016/12/22 09:55:54 序列化字节大小:18781
2016/12/22 09:55:54 GOB 序列化已用时:230 us
2016/12/22 09:55:54 序列化字节大小:9066
2016/12/22 09:55:54 XML 序列化已用:2404 us
2016/12/22 09:55:54 序列化字节大小:25780


正如您从我的结果中看到的那样，JSON 仅比 XML 大 (30%)，而 GOB 小得多。这与您的结果一致。仍然与您的结果一致，GOB 比 XML 和 JSON 快得多。

但是，JSON 序列化比 XML 序列化快得多(快 4 倍)。 GOB 的速度是 JSON 的两倍。

您会在自己的硬件上得到不同的结果，但我怀疑您会得到相当一致的数字(运行间差异很小)，尤其是当您禁用 CPU 功能(例如 TurboBoost)时。

如果我们实际序列化到磁盘或使用大块数据会发生什么？它不会改变性能排序，因为 GOB 更快更小，JSON 在数据大小和处理大小方面处于中间，而 XML 更臃肿且处理速度更慢。

所以我认为我们可以有把握地得出结论，我们有以下...

1. GOB 更小更快。

2. JSON 小而快。

3. XML 又大又慢。