当前位置：首页 > 文章列表 > Golang > Go教程 > golang进程内存控制避免docker内oom

golang进程内存控制避免docker内oom

来源：脚本之家 2022-12-22 21:41:16 0浏览收藏

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《golang进程内存控制避免docker内oom》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下进程、docker、oom，希望所有认真读完的童鞋们，都有实质性的提高。

背景

golang版本：1.16

之前遇到的问题，docker启动时禁用了oom-kill（kill后服务受损太大），导致golang内存使用接近docker上限后，进程会hang住，不响应任何请求，debug工具也无法attatch。

前文分析见：golang进程在docker中OOM后hang住问题

本文主要尝试给出解决方案

测试程序

测试程序代码如下，协程h.allocate每秒检查内存是否达到800MB，未达到则申请内存，协程h.clear每秒检查内存是否超过800MB的80%，超过则释放掉超出部分，模拟通常的业务程序频繁进行内存申请和释放的逻辑。程序通过http请求127.0.0.1:6060触发开始执行方便debug。

docker启动时加--memory 1G --memory-reservation 1G --oom-kill-disable=true参数限制总内存1G并关闭oom-kill

package main
import (
   "fmt"
   "math/rand"
   "net/http"
   _ "net/http/pprof"
   "sync"
   "sync/atomic"
   "time"
)
const (
   maxBytes = 800 * 1024 * 1024 // 800MB
   arraySize = 4 * 1024
)
type handler struct {
   start        uint32          // 开始进行内存申请释放
   total        int32           // 4kB内存总个数
   count        int             // 4KB内存最大个数
   ratio        float64         // 内存数达到count*ratio后释放多的部分
   bytesBuffers [][]byte        // 内存池
   locks        []*sync.RWMutex // 每个4kb内存一个锁减少竞争
   wg           *sync.WaitGroup
}
func newHandler(count int, ratio float64) *handler {
   h := &handler{
      count:        count,
      bytesBuffers: make([][]byte, count),
      locks:        make([]*sync.RWMutex, count),
      wg:           &sync.WaitGroup{},
      ratio:        ratio,
   }
   for i := range h.locks {
      h.locks[i] = &sync.RWMutex{}
   }
   return h
}
func (h *handler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
   atomic.StoreUint32(&h.start, 1) // 触发开始内存申请释放
}
func (h *handler) started() bool {
   return atomic.LoadUint32(&h.start) == 1
}
// 每s检查内存未达到count个则补足
func (h *handler) allocate() {
   h.wg.Add(1)
   go func() {
      defer h.wg.Done()
      ticker := time.NewTicker(time.Second)
      for range ticker.C {
         for i := range h.bytesBuffers {
            h.locks[i].Lock()
            if h.bytesBuffers[i] == nil {
               h.bytesBuffers[i] = make([]byte, arraySize)
               h.bytesBuffers[i][0] = 'a'
               atomic.AddInt32(&h.total, 1)
            }
            h.locks[i].Unlock()
            fmt.Printf("allocated size: %dKB\n", atomic.LoadInt32(&h.total)*arraySize/1024)
         }
      }
   }()
}
// 每s检查内存超过count*ratio将超出的部分释放掉
func (h *handler) clear() {
   h.wg.Add(1)
   go func() {
      defer h.wg.Done()
      ticker := time.NewTicker(time.Second)
      for range ticker.C {
         diff := int(atomic.LoadInt32(&h.total)) - int(float64(h.count)*h.ratio)
         tmp := diff
         for diff > 0 {
            i := rand.Intn(h.count)
            h.locks[i].RLock()
            if h.bytesBuffers[i] == nil {
               h.locks[i].RUnlock()
               continue
            }
            h.locks[i].RUnlock()
            h.locks[i].Lock()
            if h.bytesBuffers[i] == nil {
               h.locks[i].Unlock()
               continue
            }
            h.bytesBuffers[i] = nil
            h.locks[i].Unlock()
            atomic.AddInt32(&h.total, -1)
            diff--
         }
         fmt.Printf("free size: %dKB, left size: %dKB\n", tmp*arraySize/1024,
            atomic.LoadInt32(&h.total)*arraySize/1024)
      }
   }()
}
// 每s打印日志检查是否阻塞
func (h *handler) print() {
   h.wg.Add(1)
   go func() {
      defer h.wg.Done()
      ticker := time.NewTicker(time.Second)
      for range ticker.C {
         go func() {
            d := make([]byte, 1024) // trigger gc
            d[0] = 1
            fmt.Printf("running...%d\n", d[0])
         }()
      }
   }()
}
// 等待启动
func (h *handler) wait() {
   h.wg.Add(1)
   go func() {
      defer h.wg.Done()
      addr := "127.0.0.1:6060" // trigger to start
      err := http.ListenAndServe(addr, h)
      if err != nil {
         fmt.Printf("failed to listen on %s, %+v", addr, err)
      }
   }()
   for !h.started() {
      time.Sleep(time.Second)
      fmt.Printf("waiting...\n")
   }
}
// 等待退出
func (h *handler) waitDone() {
   h.wg.Wait()
}
func main() {
   go func() {
      addr := "127.0.0.1:6061" // debug
      _ = http.ListenAndServe(addr, nil)
   }()
   h := newHandler(maxBytes/arraySize, 0.8)
   h.wait()
   h.allocate()
   h.clear()
   h.print()
   h.waitDone()
}

程序执行一段时间后rss占用即达到1G，程序不再响应请求，docker无法通过bash连接上，已经连接的bash执行命令显示错误bash: fork: Cannot allocate memory