当我尝试用 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"))
}

为了测试，我并行运行请求并得到这些结果:

• 1 个请求:300Mo
• 5 个请求:1.5Go
• 10 个请求:3.1Go
• 更多:我的电脑死机了:)

如何减少内存消耗？

编辑

如果我不需要处理数据，它会很好用。
例如，如果我从数据库中得到 100,000 行。 然后我需要处理它们以返回具有多个级别的 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)
}

这个脚本需要大约 500 Mo 的内存并且不会释放它，而 map 甚至还没有转换成 JSON。

如何减少内存消耗和/或在多次调用时保持稳定的内存消耗状态？

谢谢你的帮助

最佳答案

分配的内存不会立即返回给操作系统，请参阅 Cannot free memory once occupied by bytes.Buffer ;和 Freeing unused memory?

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

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

像这样做:

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 数组，只需“框架”数据并在项目之间插入逗号:

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
})

关于json - 使用 Echo 或 Gin 框架的大型数组的内存消耗，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56737363/