如何在 Go 中使用 CGroup 实现进程内存控制

背景

从 Linux 内核 2.6.25 开始，CGroup 支持对进程内存的隔离和限制，这也是 Docker 等容器技术的底层支撑。

使用 CGroup 有如下好处：

在共享的机器上，进程相互隔离，互不影响，对其它进程是种保护。
对于存在内存泄漏的进程，可以设置内存限制，通过系统 OOM 触发的 Kill 信号量来实现重启。
CGroup 快速入门
默认挂载分组

Linux 系统默认支持 CGroup, 而且默认挂载所有选项，可以使用 mount -t cgroup 来查看：

$ mount -t cgroup

cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/net_cls type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct,cpu)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

CGroup 相关的资源包括 cpu,memory,blkio等，而我们今天主要关心的是内存，即 /sys/fs/cgroup/memory。

创建 climits 内存分组
我们可以使用 mkdir /sys/fs/cgroup/memory/climits 来创建属于自己的内存组 climits:

$ mkdir /sys/fs/cgroup/memory/climits

此时系统已经在目录 /sys/fs/cgroup/memory/climits 下为我们生成了内存相关的所有配置：

$ ls -la /sys/fs/cgroup/memory/climits

cgroup.clone_children  memory.kmem.limit_in_bytes          memory.kmem.tcp.usage_in_bytes  memory.memsw.max_usage_in_bytes  memory.soft_limit_in_bytes  tasks
cgroup.event_control   memory.kmem.max_usage_in_bytes      memory.kmem.usage_in_bytes      memory.memsw.usage_in_bytes      memory.stat
cgroup.procs           memory.kmem.slabinfo                memory.limit_in_bytes           memory.move_charge_at_immigrate  memory.swappiness
memory.failcnt         memory.kmem.tcp.failcnt             memory.max_usage_in_bytes       memory.numa_stat                 memory.usage_in_bytes
memory.force_empty     memory.kmem.tcp.limit_in_bytes      memory.memsw.failcnt            memory.oom_control               memory.use_hierarchy
memory.kmem.failcnt    memory.kmem.tcp.max_usage_in_bytes  memory.memsw.limit_in_bytes     memory.pressure_level            notify_on_release

主要配置含义：

  • cgroup.procs: 使用该组配置的进程列表。
  • memory.limit_in_bytes：内存使用限制。
  • memory.memsw.limit_in_bytes：内存和交换分区总计限制。
  • memory.swappiness: 交换分区使用比例。
  • memory.usage_in_bytes： 当前进程内存使用量。
  • memory.stat: 内存使用统计信息。
  • memory.oom_control: OOM 控制参数。
  • 其它，参考官方手册

设置内存限制

假设有进程 pid 1234，希望设置内存限制为 10MB，我们可以这样操作：

  • limit_in_bytes 设置为 10MB

    echo 10M > /sys/fs/cgroup/memory/climits/memory.limit_in_bytes

swappiness 设置为 0，表示禁用交换分区，实际生产中可以配置合适的比例。

echo 0 > /sys/fs/cgroup/memory/climits/memory.swappiness

添加控制进程

echo 1234 > /sys/fs/cgroup/memory/climits/cgroup.procs

当进程 1234 使用内存超过 10MB 的时候，默认进程 1234 会触发 OOM，被系统 Kill 掉。

Go 实现进程内存限制

上面我们已经讲到 CGroup 内存限制的原理，接下来我们就用 Go 代码来实现一个简单的进程内存限制以及守护（被 Kill 能够自动重启）。

  • 进程测试代码:
    该代码主要逻辑是每隔一秒申请 1MB 存储空间，并且不释放，然后再打印下 Go 的内存申请情况。

    
// example/simple_app.go
package main

import (
"fmt"
"os"
"runtime"
"time"
)

const (
MB = 1024 * 1024
)

func main() {
blocks := make([][MB]byte, 0)
fmt.Println("Child pid is", os.Getpid())

for i := 0; ; i++ {
    blocks = append(blocks, [MB]byte{})
    printMemUsage()
    time.Sleep(time.Second)
}

}

func printMemUsage() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
fmt.Printf("\tSys = %v MiB \n", bToMb(m.Sys))
}

func bToMb(b uint64) uint64 {
return b / MB
}


通过 GOOS=linux GOARCH=amd64 go build -o simpleapp example/simple_app.go 命令，编译一个 Linux 版本的可执行程序 simpleapp。

* 进程守护程序
该守护程序主要实现进程内存限制和进程守护（自动重启），代码如下：

// main.go
package main

import (
"flag"
"fmt"
"io/ioutil"
"log"
"os"
"os/exec"
"os/signal"
"path/filepath"
"syscall"
)

var (
rssLimit int
cgroupRoot string
)

const (
procsFile = "cgroup.procs"
memoryLimitFile = "memory.limit_in_bytes"
swapLimitFile = "memory.swappiness"
)

func init() {
flag.IntVar(&rssLimit, "memory", 10, "memory limit with MB.")
flag.StringVar(&cgroupRoot, "root", "/sys/fs/cgroup/memory/climits", "cgroup root path")
}

func main() {
flag.Parse()

// set memory limit
mPath := filepath.Join(cgroupRoot, memoryLimitFile)
whiteFile(mPath, rssLimit*1024*1024)

// set swap memory limit to zero
sPath := filepath.Join(cgroupRoot, swapLimitFile)
whiteFile(sPath, 0)

go startCmd("./simpleapp")

c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
s := <-c
fmt.Println("Got signal:", s)

}

func whiteFile(path string, value int) {
if err := ioutil.WriteFile(path, []byte(fmt.Sprintf("%d", value)), 0755); err != nil {
log.Panic(err)
}
}

type ExitStatus struct {
Signal os.Signal
Code int
}

func startCmd(command string) {
restart := make(chan ExitStatus, 1)

runner := func() {
    cmd := exec.Cmd{
        Path: command,
    }

    cmd.Stdout = os.Stdout

    // start app
    if err := cmd.Start(); err != nil {
        log.Panic(err)
    }

    fmt.Println("add pid", cmd.Process.Pid, "to file cgroup.procs")

    // set cgroup procs id
    pPath := filepath.Join(cgroupRoot, procsFile)
    whiteFile(pPath, cmd.Process.Pid)

    if err := cmd.Wait(); err != nil {
        fmt.Println("cmd return with error:", err)
    }

    status := cmd.ProcessState.Sys().(syscall.WaitStatus)

    options := ExitStatus{
        Code: status.ExitStatus(),
    }

    if status.Signaled() {
        options.Signal = status.Signal()
    }

    cmd.Process.Kill()

    restart <- options
}

go runner()

for {
    status := <-restart

    switch status.Signal {
    case os.Kill:
        fmt.Println("app is killed by system")
    default:
        fmt.Println("app exit with code:", status.Code)
        return
    }

    fmt.Println("restart app..")
    go runner()
}

}


这段代码的主要逻辑为：

通过配置参数 memory ，修改 memory.limit_in_bytes 和 memory.swappiness 来设置最大内存使用量。
通过 cmd.Start() 启动一个进程。
将新生成的进程号 cmd.Process.Pid 写到 cgroup.procs。
通过 cmd.Wait() 接收命令输出结果。
如果返回结果为 Kill 信号的时候，能够重启任务。
通过 GOOS=linux GOARCH=amd64 go build -o climits main.go 命令，编译一个 Linux 版本的可执行程序 climits。

### 运行示例
我们已经提前创建了一个叫做 climits 的内存相关 CGroup，并且目录下包含 climits, simpleapp 两个可执行程序。

此时运行命令 ./climits -memory 60，可以看到如下输出：

[[email protected] climits]# ./climit -memory 60
add pid 48189 to file cgroup.procs
Child pid is 48189
Alloc = 1 MiB Sys = 66 MiB
Alloc = 3 MiB Sys = 66 MiB
Alloc = 8 MiB Sys = 68 MiB
Alloc = 8 MiB Sys = 68 MiB
Alloc = 16 MiB Sys = 68 MiB
Alloc = 16 MiB Sys = 68 MiB
...
Alloc = 32 MiB Sys = 134 MiB
Alloc = 32 MiB Sys = 134 MiB
cmd return with error: signal: killed
app is killed by system
restart app..
add pid 48256 to file cgroup.procs
Child pid is 48256
Alloc = 1 MiB Sys = 66 MiB
Alloc = 3 MiB Sys = 68 MiB
Alloc = 4 MiB Sys = 68 MiB
Alloc = 12 MiB Sys = 68 MiB
^CGot signal: interrupt



通过输出可以看出，当内存超过一定限制后，进程 48189 会被 Kill 掉，守护程序收到 Kill 信号后，会先关闭老进程，再重启新进程 48256。

## 总结
这篇文章主要简单介绍了 CGroup 控制进程内存的原理，并通过 Go 代码实现一个简单的进程守护，支持内存限制和进程重启。我们还可以通过它来查看进程内存使用详细信息，以此完成一个简易内存 container。

参考链接：

* [man7/cgroups](http://man7.org/linux/man-pages/man7/cgroups.7.html)
* [限制cgroup的内存使用](https://segmentfault.com/a/1190000008125359)
* [climits源代码](https://github.com/songjiayang/climits)

作者：宋佳洋
出处：http://www.songjiayang.com/posts/shi-yong-cgroup-shi-xian-nei-cun-kong-zhi

### 51Reboot golang课程 6.15开班
### 有想要咨询的WeChat：17812796384

原文地址：https://blog.51cto.com/51reboot/2404442

时间： 2024-11-09 00:49:43

如何在 Go 中使用 CGroup 实现进程内存控制的相关文章

如何在MVC中显示条形码图片(以内存流的方式)

前台代码: <script type="text/javascript"> function fresh() { var getimagecode = document.getElementById("testimg"); var val = document.getElementById("txtcontent").value; getimagecode.src = "../Home/codeindex?content=&

如何在Service中更新Activity的UI？

============问题描述============ 如何在Service中更新Activity的UI? 不想用广播.  有人说用接口,具体如何实现我一直不懂? 请赐教. ============解决方案1============ 将activity 实例传过来不就OK 了?然后调用其方法更新UI ============解决方案2============ 一般都用广播,否则在Activity也创建一个Messenger,也就是AIDL方式通信. ============解决方案3=====

如何在App中实现IM功能之二快速实现离线消息模块——箭扣科技Arrownock

如何在App中实现IM功能 之二 快速实现离线消息模块 一个App在实际使用聊天功能的时候,并非是一直呆在一个界面的,在等待好友发消息来的同时,有可能已经跳转到其他界面,也有可能切换到其他App. 在当前的App进入后台.好友发来消息时,需要给设备推送一条消息.以安卓为例,收取离线消息通知需要绑定anPush,具体做法是调用anIM.bindAnPushService(anID, AppKey, anPushType). 在App进入后台时,调用anIM.disconnect():在App回到前

如何在tsung中使用动态参数（一）

这两天给公司一个新项目做上线前的压力测试,这个项目主要的接口有两个,获取订单号(getOrderId)和确认订单(confirm),需要重点压测.开始,我们选择用python写测试例,python的好处是开发迅速,但是并发能力不够:我就想试试用tsung,tsung是用erlang写的,并发肯定没问题,但我以前只用来测试过静态网站,没有测试过动态API,查了查文档,发现tsung是支持用erlang脚本生成动态参数的,于是我决定用tsung. tsung的安装略过,看一下getorderId的配

如何在Ruby中编写微服务？

[编者按]本文作者为 Pierpaolo Frasa,文章通过详细的案例,介绍了在Ruby中编写微服务时所需注意的方方面面.系国内 ITOM 管理平台 OneAPM 编译呈现. 最近,大家都认为应当采用微服务架构.但是,又有多少相关教程呢?我们来看看这篇关于用Ruby编写微服务的文章吧. 人人都在讨论微服务,但我至今也没见过几篇有关用Ruby编写微服务的.像样的教程.这可能是因为许多Ruby开发人员仍然最喜欢Rails架构(这没什么不好,Rails本身也没什么不好,但是Ruby可以做到的事还有很

用代码说话：如何在Java中实现线程

并发编程是Java语言的重要特性之一,"如何在Java中实现线程"是学习并发编程的入门知识,也是Java工程师面试必备的基础知识.本文从线程说起,然后用代码说明如何在Java中实现线程. 一.什么是线程? 线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.程序员可以通过它进行多处理器编程,也可以使用多线程对运算密集型任务提速.如果使用得当,线程可以有效地降低程序的开发和运维成本,同时能够提升程序的性能. 二.线程和进程有什么区别? 线程是进程的子集,

如何在makfile中查看变量的值

在makefile中查看变量的取值是多少应该是一个比较麻烦的问题,但是本大神自己研究出一个十分方便的方法.这个方法十分简单.现在介绍如下 如果在一个十分复杂庞大的makefile文件中,有个地方用到一个变量SRC_FILE,你很想知道makefile运行到此处的时候这个变量的值为多少.那么你可以在这个变量的下面写两行东东: $(shell echo $(SRC_FILE) > readme.txt ) rrrrrrrrrrrrrrrrrrr 第一行其实是调用shell命令来将这个变量的值输入到r

如何在Angular2-cli中使用插件(不使用配置)

重要点: 要把插件放在src/assets文件中 如何在angular-cli中使用jquery插件 a.在index.html中引入 <script  src="./assets/jquery-1.8.3.min.js"></script> b. 在要使用jquery的组件中声明(XX.component.ts) declare var $ : any; c.导入onInit import { OnInit} from '@angular/core'; d.输

Excel技巧|如何在Excel中快速的批量将unix时间戳转化为北京时间

本文标签:  Excel技巧 unix时间戳转化北京时间 Excel时间戳转化北京时间 互联网杂谈 批量将将unix时间戳转化为北京时间 方法/步骤 单击要获得北京时间的那一列,右键,选择[设置单元格格式],在弹出的窗口中,左侧选择 [日期],右侧选择你想要的时间格式,点击确定. 选中其中一个单元格,输入公式 =(A2+8*3600)/86400+70*365+19 其中,A2是要转化的时间戳的单元格. 输入完公式,按下[回车键]. 该时间戳即转化为北京时间. 选中上面转化好的北京时间单元格,鼠