使用 Echo 或 Gin 框架的大型数组的内存消耗

Memory consumption with large array with Echo or Gin framework

当我尝试使用 Echo(还有 Gin)发送大型数组时出现内存问题。 请求后,内存不空闲。

package main

import (
    "net/http"
    "strconv"

    "github.com/labstack/echo"
)

type User struct {
    Username  string
    Password  string
    Lastname  string
    Firstname string
}

func main() {
    e := echo.New()
    e.GET("/", func(c echo.Context) error {
        var user User
        users := make([]User, 0)

        for i := 0; i < 100000; i++ {
            user = User{
                Username:  "ffgfgfghhfghfhgfgfhgfghfghfhgfhgfh" + strconv.Itoa(i),
                Password:  "gjgjghjgjhgjhghjfrserhkhjhklljjkbhjvftxersgdghjjkhkljkbhftd",
                Lastname:  "njuftydfhgjkjlkjlkjlkhjkhu",
                Firstname: "jkggkjkl,,lm,kljkvgf"}

            users = append(users, user)
        }

        defer func() {
            users = nil
        }()
        return c.JSON(http.StatusOK, users)
    })
    e.Logger.Fatal(e.Start(":1323"))
}

为了测试,我 运行 并行请求,结果如下:

如何减少内存消耗?

编辑

如果我不需要处理数据,它会很好用。
例如,如果我从数据库中得到 100,000 行。 然后我需要将它们处理成具有多个级别的 return a JSON。在这种情况下,我不得不创建一个数组或映射。
但问题是内存永远不会释放。它随着每个请求而增加,在并行请求的情况下更糟。

举个例子:

import (
    "strconv"
    "time"
)

type sqlDataType struct {
    ApplicationID        int
    ApplicationName      string
    ApplicationCreatedAt time.Time
    ApplicationUpdatedAt time.Time
    ModuleID             int
    ModuleName           string
    ModuleCreatedAt      time.Time
    ModuleUpdatedAt      time.Time
    ActionID             int
    ActionName           string
    ActionCreatedAt      time.Time
    ActionUpdatedAt      time.Time
}

type DataApplicationType struct {
    Name      string
    CreatedAt time.Time
    UpdatedAt time.Time
    Modules   map[int]dataModuleType
}

type dataModuleType struct {
    Name      string
    CreatedAt time.Time
    UpdatedAt time.Time
    Actions   map[int]dataActionType
}

type dataActionType struct {
    Name      string
    CreatedAt time.Time
    UpdatedAt time.Time
}

// InitData inits data for test
func InitData() map[int]DataApplicationType {
    data := make(map[int]DataApplicationType)

    const nbApplications = 10
    const nbModules = 1000
    const nbActions = 100000

    sqlData := make([]sqlDataType, 0)
    for i := 0; i < nbActions; i++ {
        line := sqlDataType{
            ApplicationID:        (i % nbApplications) + 1,
            ApplicationName:      "Application " + strconv.Itoa((i%nbApplications)+1),
            ApplicationCreatedAt: time.Now(),
            ApplicationUpdatedAt: time.Now(),
            ModuleID:             (i % nbModules) + 1,
            ModuleName:           "Module " + strconv.Itoa((i%nbModules)+1),
            ModuleCreatedAt:      time.Now(),
            ModuleUpdatedAt:      time.Now(),
            ActionID:             i + 1,
            ActionName:           "Action " + strconv.Itoa(i+1),
            ActionCreatedAt:      time.Now(),
            ActionUpdatedAt:      time.Now(),
        }

        sqlData = append(sqlData, line)
    }

    nbData := len(sqlData)
    for i := 0; i < nbData; i++ {
        if _, ok := data[sqlData[i].ApplicationID]; !ok {
            dac := new(dataActionType)
            dac.Name = sqlData[i].ActionName
            dac.CreatedAt = sqlData[i].ActionCreatedAt
            dac.UpdatedAt = sqlData[i].ActionUpdatedAt

            dmo := new(dataModuleType)
            dmo.Name = sqlData[i].ModuleName
            dmo.CreatedAt = sqlData[i].ModuleCreatedAt
            dmo.UpdatedAt = sqlData[i].ModuleUpdatedAt
            dmo.Actions = make(map[int]dataActionType)
            dmo.Actions[sqlData[i].ActionID] = *dac

            dap := new(DataApplicationType)
            dap.Name = sqlData[i].ApplicationName
            dap.CreatedAt = sqlData[i].ApplicationCreatedAt
            dap.UpdatedAt = sqlData[i].ApplicationUpdatedAt
            dap.Modules = make(map[int]dataModuleType)
            dap.Modules[sqlData[i].ModuleID] = *dmo

            data[sqlData[i].ApplicationID] = *dap
        }

        if _, ok := data[sqlData[i].ApplicationID].Modules[sqlData[i].ModuleID]; !ok {
            dac := new(dataActionType)
            dac.Name = sqlData[i].ActionName
            dac.CreatedAt = sqlData[i].ActionCreatedAt
            dac.UpdatedAt = sqlData[i].ActionUpdatedAt

            dmo := new(dataModuleType)
            dmo.Name = sqlData[i].ModuleName
            dmo.CreatedAt = sqlData[i].ModuleCreatedAt
            dmo.UpdatedAt = sqlData[i].ModuleUpdatedAt
            dmo.Actions = make(map[int]dataActionType)
            dmo.Actions[sqlData[i].ActionID] = *dac

            data[sqlData[i].ApplicationID].Modules[sqlData[i].ModuleID] = *dmo
        }

        if _, ok := data[sqlData[i].ApplicationID].Modules[sqlData[i].ModuleID].Actions[sqlData[i].ActionID]; !ok {
            dac := new(dataActionType)
            dac.Name = sqlData[i].ActionName
            dac.CreatedAt = sqlData[i].ActionCreatedAt
            dac.UpdatedAt = sqlData[i].ActionUpdatedAt

            data[sqlData[i].ApplicationID].Modules[sqlData[i].ModuleID].Actions[sqlData[i].ActionID] = *dac
        }
    }

    return data
}

在main.go中:

func main() {
    // Lancement de Cobra
    // commands.Execute()
    go issues.InitData()
    go issues.InitData()
    go issues.InitData()
    go issues.InitData()
    go issues.InitData()

    time.Sleep(60 * time.Second)
}

这个脚本需要大约500Mo的内存并且没有释放它,而地图甚至还没有被转换成JSON。

如何减少内存消耗and/or我可以在多次调用时保持稳定的内存消耗状态?

谢谢你的帮助

分配的内存不会立即 return返回 OS,请参阅 ; and

您的回答几乎没有改进,因为您仍在内存中构建 (Go) 数组(或更确切地说是切片),一旦完成,您才继续将其编组到响应中。您还为每个项目创建一个新的编码器,编组一个项目,然后将其丢弃。您可以使用 json.Encoder 编组多个项目。您还会在每个项目之后刷新响应,这也非常低效。这违背了所有内部缓冲的目的...

相反,您可以在项目 (User) 准备就绪后立即编组它们,这样您就不必将所有内容都保存在内存中。并且不要在每个用户之后刷新,最后执行一次就足够了,这是没有必要的,因为一旦您从处理程序 return,服务器将刷新所有缓冲的数据。

像这样做:

e.GET("/", func(c echo.Context) error {
    c.Response().WriteHeader(http.StatusOK)

    enc := json.NewEncoder(c.Response())
    for i := 0; i < 100000; i++ {
        user := User{
            Username:  "ffgfgfghhfghfhgfgfhgfghfghfhgfhgfh" + strconv.Itoa(i),
            Password:  "gjgjghjgjhgjhghjfrserhkhjhklljjkbhjvftxersgdghjjkhkljkbhfd",
            Lastname:  "njuftydfhgjkjlkjlkjlkhjkhu",
            Firstname: "jkggkjkl,,lm,kljkvgf",
        }
        if err := enc.Encode(user); err != nil {
            return err
        }
    }

    return nil
})

这里要注意一件事:上面的代码并没有向输出发送一个 JSON 数组,它发送了一系列 JSON 对象。如果这不适合您并且您确实需要发送单个 JSON 数组,只需 "frame" 数据并在项目之间插入逗号:

e.GET("/", func(c echo.Context) error {
    resp := c.Response()
    resp.WriteHeader(http.StatusOK)

    if _, err := io.WriteString(resp, "["); err != nil {
        return err
    }
    enc := json.NewEncoder(resp)
    for i := 0; i < 100000; i++ {
        if i > 0 {
            if _, err := io.WriteString(resp, ","); err != nil {
                return err
            }
        }
        user := User{
            Username:  "ffgfgfghhfghfhgfgfhgfghfghfhgfhgfh" + strconv.Itoa(i),
            Password:  "gjgjghjgjhgjhghjfrserhkhjhklljjkbhjvftxersgdghjjkhkljkbhft",
            Lastname:  "njuftydfhgjkjlkjlkjlkhjkhu",
            Firstname: "jkggkjkl,,lm,kljkvgf",
        }
        if err := enc.Encode(user); err != nil {
            return err
        }
    }
    if _, err := io.WriteString(resp, "]"); err != nil {
        return err
    }

    return nil
})