作者:John Graham-Cumming.   原文点击此处。翻译:Lubia Yang(已失效)

前些天我介绍了我们对Lua的使用,implement our new Web Application Firewall.

另一种在CloudFlare (作者的公司)变得非常流行的语言是Golang。在过去,我写了一篇 how we use Go来介绍类似Railgun的网络服务的编写。

用Golang这样带GC的语言编写长期运行的网络服务有一个很大的挑战,那就是内存管理。

为了理解Golang的内存管理有必要对run-time源码进行深挖。有两个进程区分应用程序不再使用的内存,当它们看起来不会再使用,就把它们归还到操作系统(在Golang源码里称为scavenging )。

这里有一个简单的程序制造了大量的垃圾(garbage),每秒钟创建一个 5,000,000 到 10,000,000 bytes 的数组。程序维持了20个这样的数组,其他的则被丢弃。程序这样设计是为了模拟一种非常常见的情况:随着时间的推移,程序中的不同部分申请了内存,有一些被保留,但大部分不再重复使用。在Go语言网络编程中,用goroutines 来处理网络连接和网络请求时(network connections or requests),通常goroutines都会申请一块内存(比如slice来存储收到的数据)然后就不再使用它们了。随着时间的推移,会有大量的内存被网络连接(network connections)使用,连接累积的垃圾come and gone。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package main
 
import ( 
    "fmt" 
    "math/rand" 
    "runtime" 
    "time"
 
func makeBuffer() []byte { 
    return make([]byte, rand.Intn(5000000)+5000000) 
}
 
func main() { 
    pool := make([][]byte, 20)
 
    var m runtime.MemStats 
    makes := 0 
    for 
        b := makeBuffer()
        makes += 1
        i := rand.Intn(len(pool))
        pool[i] = b
 
        time.Sleep(time.Second)
 
        bytes := 0
 
        for i := 0; i < len(pool); i++ {
            if pool[i] != nil {
                bytes += len(pool[i])
            }
        }
 
        runtime.ReadMemStats(&m)
        fmt.Printf("%d,%d,%d,%d,%d,%d\n", m.HeapSys, bytes, m.HeapAlloc,
            m.HeapIdle, m.HeapReleased, makes)
    }
}

程序使用 runtime.ReadMemStats函数来获取堆的使用信息。它打印了四个值,

HeapSys:程序向应用程序申请的内存

HeapAlloc:堆上目前分配的内存

HeapIdle:堆上目前没有使用的内存

HeapReleased:回收到操作系统的内存

GC在Golang中运行的很频繁(参见GOGC环境变量(GOGC environment variable )来理解怎样控制垃圾回收操作),因此在运行中由于一些内存被标记为”未使用“,堆上的内存大小会发生变化:这会导致HeapAlloc和HeapIdle发生变化。Golang中的scavenger 会释放那些超过5分钟仍然没有再使用的内存,因此HeapReleased不会经常变化。

下面这张图是上面的程序运行了10分钟以后的情况:

(在这张和后续的图中,左轴以是以byte为单位的内存大小,右轴是程序执行次数)

红线展示了pool中byte buffers的数量。20个 buffers 很快达到150,000,000 bytes。最上方的蓝色线表示程序从操作系统申请的内存。稳定在375,000,000 bytes。因此程序申请了2.5倍它所需的空间!

当GC发生时,HeapIdle和HeapAlloc发生跳变。橘色的线是makeBuffer()发送的次数。

这种过度的内存申请是有GC的程序的通病,参见这篇paper

Quantifying the Performance of Garbage Collection vs. Explicit Memory Management

程序不断执行,idle memory(即HeapIdle)会被重用,但很少归还到操作系统。

解决此问题的一个办法是在程序中手动进行内存管理。例如,

程序可以这样重写:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package main
 
import (
    "fmt"
    "math/rand"
    "runtime"
    "time"
)
 
func makeBuffer() []byte {
    return make([]byte, rand.Intn(5000000)+5000000)
}
 
func main() {
    pool := make([][]byte, 20)
 
    buffer := make(chan []byte, 5)
 
    var m runtime.MemStats
    makes := 0
    for {
        var b []byte
        select {
        case b = <-buffer:
        default:
            makes += 1
            b = makeBuffer()
        }
 
        i := rand.Intn(len(pool))
        if pool[i] != nil {
            select {
            case buffer <- pool[i]:
                pool[i] = nil
            default:
            }
        }
 
        pool[i] = b
 
        time.Sleep(time.Second)
 
        bytes := 0
        for i := 0; i < len(pool); i++ {
            if pool[i] != nil {
                bytes += len(pool[i])
            }
        }
 
        runtime.ReadMemStats(&m)
        fmt.Printf("%d,%d,%d,%d,%d,%d\n", m.HeapSys, bytes, m.HeapAlloc,
            m.HeapIdle, m.HeapReleased, makes)
    }
}

下面这张图是上面的程序运行了10分钟以后的情况:

这张图展示了完全不同的情况。实际使用的buffer几乎等于从操作系统中申请的内存。同时GC几乎没有工作可做。堆上只有很少的HeapIdle最终需要归还到操作系统。

这段程序中内存回收机制的关键操作就是一个缓冲的channel ——buffer,在上面的代码中,buffer是一个可以存储5个[]byte slice的容器。当程序需要空间时,首先会使用select从buffer中读取:

select {

case b = <- buffer:

default :

makes += 1

b = makeBuffer()

}

这永远不会阻塞因为如果channel中有数据,就会被读出,如果channel是空的(意味着接收会阻塞),则会创建一个。

使用类似的非阻塞机制将slice回收到buffer:

select {

case buffer <- pool[i]:

pool[i] = nil

default:

}

如果buffer 这个channel满了,则以上的写入过程会阻塞,这种情况下default触发。这种简单的机制可以用于安全的创建一个共享池,甚至可通过channel传递实现多个goroutines之间的完美、安全共享。

在我们的实际项目中运用了相似的技术,实际使用中(简单版本)的回收器(recycler )展示在下面,有一个goroutine 处理buffers的构造并在多个goroutine之间共享。get(获取一个新buffer)和give(回收一个buffer到pool)这两个channel被所有goroutines使用。

回收器对收回的buffer保持连接,并定期的丢弃那些过于陈旧可能不会再使用的buffer(在示例代码中这个周期是一分钟)。这让程序可以自动应对爆发性的buffers需求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package main
 
import (
    "container/list"
    "fmt"
    "math/rand"
    "runtime"
    "time"
)
 
var makes int
var frees int
 
func makeBuffer() []byte {
    makes += 1
    return make([]byte, rand.Intn(5000000)+5000000)
}
 
type queued struct {
    when time.Time
    slice []byte
}
 
func makeRecycler() (get, give chan []byte) {
    get = make(chan []byte)
    give = make(chan []byte)
 
    go func() {
        q := new(list.List)
        for {
            if q.Len() == 0 {
                q.PushFront(queued{when: time.Now(), slice: makeBuffer()})
            }
 
            e := q.Front()
 
            timeout := time.NewTimer(time.Minute)
            select {
            case b := <-give:
                timeout.Stop()
                q.PushFront(queued{when: time.Now(), slice: b})
 
           case get <- e.Value.(queued).slice:
               timeout.Stop()
               q.Remove(e)
 
           case <-timeout.C:
               e := q.Front()
               for e != nil {
                   n := e.Next()
                   if time.Since(e.Value.(queued).when) > time.Minute {
                       q.Remove(e)
                       e.Value = nil
                   }
                   e = n
               }
           }
       }
 
    }()
 
    return
}
 
func main() {
    pool := make([][]byte, 20)
 
    get, give := makeRecycler()
 
    var m runtime.MemStats
    for {
        b := <-get
        i := rand.Intn(len(pool))
        if pool[i] != nil {
            give <- pool[i]
        }
 
        pool[i] = b
 
        time.Sleep(time.Second)
 
        bytes := 0
        for i := 0; i < len(pool); i++ {
            if pool[i] != nil {
                bytes += len(pool[i])
            }
        }
 
        runtime.ReadMemStats(&m)
        fmt.Printf("%d,%d,%d,%d,%d,%d,%d\n", m.HeapSys, bytes, m.HeapAlloc
             m.HeapIdle, m.HeapReleased, makes, frees)
    }
}

执行程序10分钟,图像会类似于第二幅:

这些技术可以用于程序员知道某些内存可以被重用,而不用借助于GC,可以显著的减少程序的内存使用,同时可以使用在其他数据类型而不仅是[]byte slice,任意类型的Go type(用户定义的或许不行(user-defined or not))都可以用类似的手段回收。

 
 

golang手动管理内存的更多相关文章

  1. iOS手动管理内存

    虽然iOS已经有了ARC帮你自动管理内存,但在有些项目中必须采用手动的方式,而且在懂得手动管理内存的情况下会是自己的代码更加完善 众所周知,基于手动管理内存的情况下必然涉及到 relese  reta ...

  2. xcode 手动管理内存 的相关知识点总结

    一.XCode4.2以后支持自动释放内存ARC xcode自4.2以后就支持自动释放内存了,但有时我们还是想手动管理内存,这如何处理呢. 很简单,想要取消自动释放,只要在  Build Setting ...

  3. jvm是如何管理内存的

    1.JVM是如何管理内存的 Java中,内存管理是JVM自动进行的,无需人为干涉. 了解Java内存模型看这里:java内存模型是什么样的 了解jvm实例结构看这里:jvm实例的结构是什么样的 创建对 ...

  4. iOS 非ARC基本内存管理系列 2-多对象内存管理(3) 利用@property来自动管理内存

    iOS 基本内存管理-多对象内存管理(2)中可以看到涉及到对象的引用都要手动管理内存:每个对象都需要写如下代码 // 1.对要传入的"新车"对象car和目前Person类对象所拥有 ...

  5. OCP读书笔记(13) - 管理内存

    SGA 1. 什么是LRULRU表示Least Recently Used,也就是指最近最少使用的buffer header链表LRU链表串联起来的buffer header都指向可用数据块 2. 什 ...

  6. 浅谈javascript性能-管理内存

    上次说到,javascript脚本到底应该放在哪里?用什么用处? 以下2点: 在Html.Body部分中的JS会在页面加载的时候执行.即-用户触发一个事件的时候执行的脚本.eg:onload事件... ...

  7. 内存管理 & 内存优化技巧 浅析

    内存管理 浅析 下列行为都会增加一个app的内存占用: 1.创建一个OC对象: 2.定义一个变量: 3.调用一个函数或者方法. 如果app占用内存过大,系统可能会强制关闭app,造成闪退现象,影响用户 ...

  8. Oracle DB管理内存

    • 描述SGA 中的内存组件• 实施自动内存管理• 手动配置SGA 参数• 配置自动PGA 内存管理  内存管理:概览DBA 必须将内存管理视为其工作中至关重要的部分,因为:• 可用内存空间量有限• ...

  9. golang包管理工具

    软件开发中,不可避免的会使用到第三方库,因此包管理工具可以极大的方便开发者管理第三方依赖,避免掉入"依赖地狱". 作为google强大背书的golang语言,golang官方包管理 ...

随机推荐

  1. CSS 黑魔法小技巧,让你少写不必要的JS,代码更优雅

    首页   登录注册         CSS 黑魔法小技巧,让你少写不必要的JS,代码更优雅 阅读 8113 收藏 927 2017-09-26 原文链接:github.com 腾讯云容器服务CSS,立 ...

  2. 【全局变量】mysql查看全局变量以及设置全局变量的值

    1.查看mysql的所有全局变量的值 SHOW GLOBAL VARIABLES 或者 SHOW VARIABLES mysql有很多全局变量,包括系统的一些基本信息,以及mysql的一些基本配置都可 ...

  3. 键盘事件keydown、keypress、keyup

    事件触发顺序:keydown - > keypress - > keyup   中文输入法:   firfox:输入触发keydown,回车确认输入触发keyup chrome:输入触发k ...

  4. TeamViewer下载地址

    http://www.teamviewer.com/zhCN/download/linux.aspx Ubuntu配置远程访问的xrdp协议和teamviewer软件 先启用远程设置:System-& ...

  5. ubuntu16.04安装docker CE

    如需开始在 Ubuntu 上使用 Docker CE,请确保您满足先决条件,然后再安装 Docker. 如需安装 Docker 企业版 (Docker EE),请转至获取适用于 Ubuntu 的 Do ...

  6. 如何将Windows8系统的磁盘格式(GPT格式)转换成Windows 7系统的磁盘格式(MBR格式)

    知识点分析:随机预装Win8的电脑,磁盘为GPT格式的,如果需要安装Win7等早期版本系统,需要转换为MBR格式的,使用Diskpart命令即可完成转换.操作步骤: 注意:转换磁盘格式需要清空磁盘中的 ...

  7. android日期时间选择器

    android原生的日期时间控件,因为是原生的总有其满足不了我们需求的时候,Android 手机版本那么多,用户弹出来的控件五花八门.因为项目需要,在网上找了一 些demo看了看,感觉有些写的很好,很 ...

  8. NOIP 2014飞扬的小鸟(DP优化)

    题目链接  飞扬的小鸟 考场的70分暴力(实际只有50分因为数组开小了……) 考场代码(数组大小已修改) #include <cstdio> #include <cstring> ...

  9. f5长连接策略

    但是把这些短连接汇聚到一起,集中F5的设备上,通过F5与服务器建立平滑的长连接,就解决了不断增大的并发连接.比如说前台有15万个并发连接,经过F5的优化,在服务器上只有不到5000个并发连接,而且在此 ...

  10. [置顶] 一个简单好用的zabbix告警信息发送工具

    之前使用邮件和短信发送zabbix告警信息,但告警信息无法实时查看或者无法发送,故障无法及时通知运维人员. 后来使用第三方微信接口发送信息,愉快地用了一年多,突然收费了. zabbix告警一直是我的痛 ...