node内存控制

发表于   |   分类于   |  

垃圾回收机制

  • nodejs在执行JavaScript时，内存受到v8限制,64位约为1.4g,32位0.7g
  • 所有js对象是通过堆分配，查看process.memoryUsage()
  • 限制内存原因：垃圾回收时，js线程会暂停执行（避免JS应用逻辑与垃圾回收器看到的不一样），大量的堆内存回收严重影响性能

  • v8内存整体包含新生代和老生代

    // 调整内存限制的大小
node --max-old-space-size=1700 test.js // 单位为MB 
node --max-new-space-size=1024 test.js // 单位为KB

在V8初始化时生效,一旦生效不能动态变化

新生代

  • 由两个reserved_semispacesize（32位16mb,62位32mb）构成
  • 通过Scavenge算法进行回收，具体实现采用Cheney算法

Cheney算法采用复制方式实现垃圾回收，将堆内存分成2块，一个使用（From），一个空闲(To).分配对象在From空间。开始垃圾回收时，检查From里的存活对象，并将它们复制到To，非存活对象占用的空间会被释放，然后From、to角色对换。将存活对象在两个空间之间复制

优点是时间短、缺点是只能使用一半堆内存。新生代对象生命周期短，适合此算法

当对象经过多次复制依然存活，就会晋升到老生代。对像晋升的条件，是否经历过Scavenge回收,To空间内存占用比超过限制

老生代

  • 在64未系统下为1400 MB,在32为700 MB
  • 使用Mark-Sweep和Mark-Compact进行垃圾回收

Mark-Sweep 标记清除,先遍历堆的对象，标记活的对象，之后清除没标记的对象。死对象在老生代只占少部分，所以高效

Mark-Compact 整理内存，将Mark-Sweep清理后散开的对象移动到一段。

v8主要使用Mark-Sweep,在空间不足以对新晋升对象分配时才用Mark-Compact

增量标记(incremental marking)

  • 降低老生代的全堆垃圾回收带来的时间停顿
  • 从标记阶段入手，拆分为许多小步进，与应用逻辑交替运行
  • 垃圾回收最大停顿时间降为原来的1/6

垃圾回收是影响性能的因素之一，要尽量减少垃圾回收，尤其全堆垃圾回收

查看垃圾回收日志

  • 在启动时添加–trace_gc

启动时使用–prof,可以得到v8性能分析数据，包含垃圾回收占用的时间，需要使用工具读取，在Node源码的deps/v8/tools，linux-tick-processor

高效使用内存

作用域

  • js中能形成作用域的有函数调用、with和全局作用域

例如，在函数调用时，会创建对应的作用域，在执行结束后销毁，并且在该作用域申明的局部变量也会被销毁

  1. 标识符查找（即变量名） 先查找当前作用域，再向上级作用域，一直到全局作用域
  2. 变量主动释放 全局变量要直到进程退出才释放，导致引用对象常驻老生代，可以用delete删除或者赋undefined、null(delete删除对象的属性可能干扰v8,所以赋值更好)

闭包

  • 外部作用域访问内部作用域的方法，得益于高阶函数特性
1
2
3
4
5
6
7
8
9
10
var foo = function() {
	var bar = function() {
		var local = "局部变量";
		return function() {
			return local;
		};
	};
	var baz = bar();
	console.log(baz());
};

bar()返回一个匿名函数,一旦 有变量引用它，它的作用域将不会释放，直到没有引用

把闭包赋值给一个不可控的对象时，会导致内存泄漏。使用完，将变量赋其他值或置空

查看内存使用情况

  • 查看进程内存占用 process.memoryUsage(),其中rss为进程的常驻内存（node所占的内存），heapTotal、heapUsed为堆内存使用情况
  • os.totalmem(),os.freemem() 查看系统内存

Node使用的内存不是都通过v8分配，还有堆外内存,用于处理网络流、I/O流

内存泄漏

造成的原因：缓存、队列消费不及时、作用域未释放

缓存

  • 限制内存当缓存，要限制好大小，做好释放
  • 进程之间不能共享内存，所以用内存做缓存也是

为了加速模块引入，模块会在编译后缓存，由于通过exports导出(闭包),作用域不会释放，常驻老生代。要注意内存泄漏

1
2
3
4
5
var leakArray = [];
exports.leak = function() {
	leakArray.push("leak" + Math.random());
};
//局部变量leakArray不停增加内存占用，且不会释放，如果必须如此设计，要提供释放接口

推荐使用进程外缓存，Redis、Memcached

队列状态

  • 在生产者和消费者中间
  • 监控队列的长度，超过长度就拒绝
  • 任意的异步调用应该包含超时机制

内存泄漏排查

node-heapdump
  1. 安装 npm install heapdump
  2. 在开头引入 var heapdump = require(‘heapdump’);
  3. 发送命令kill -USR2 ，heapdump会抓拍一份堆内存快照，文件为heapdump-..heapsnapshot格式，是json文件
node-memwatch
1
2
3
4
5
6
7
8
var memwatch = require('memwatch');
memwatch.on('leak', function(info) {
	console.log('leak:');
	console.log(info);
});
memwatch.on('stats', function(stats) {
	console.log('stats:') console.log(stats);
});

在进程使用node-memwatch后，每次全堆垃圾回收，会触发stats事件，该事件会传递内存的统计信息

1
2
3
4
5
6
7
8
9
10
stats: {
		num_full_gc: 4, //   第几次全堆垃圾回收
		num_inc_gc: 23, //    第几次增量垃圾回收 
		heap_compactions: 4, //  第几次对老生代整理
		usage_trend: 0, // 使用趋势
		estimated_base: 7152944, // 预估基数 
		current_base: 7152944, // 当前基数
		min: 6720776, //  最小
		max: 7152944  //最大
	}

如果经过连续的5次垃圾回收后，内存仍没有被释放，意味有内存泄漏，node-memwatch会触发leak事件

1
2
3
4
5
6
7
leak: 8 {
	start: Mon Oct 07 2013 13: 46: 27 GMT + 0800(CST),
	end: Mon Oct 07 2013 13: 54: 40 GMT + 0800(CST),
	growth: 6222576,
	reason: 'heap growth over 5 consecutive GCs (8m 13s) - 43.33 mb/hr'
}
//显示内存增长了多了

使用node-memwatch的抓取快照和比较快照，能将内存泄漏定位到v8的堆上

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
var memwatch = require('memwatch');
var leakArray = [];
var leak = function() {
	leakArray.push("leak" + Math.random());
};
// Take first snapshot
var hd = new memwatch.HeapDiff();
for (var i = 0; i < 10000; i++) {
	leak();
}
// Take the second snapshot and compute the diff 
var diff = hd.end();
console.log(JSON.stringify(diff, null, 2));
{
	"before": {
		"nodes": 11719,
		"time": "2013-10-07T06:32:07.000Z",
		"size_bytes": 1493304,
		"size": "1.42 mb"
	},
	"after": {
		"nodes": 31618,
		"time": "2013-10-07T06:32:07.000Z",
		"size_bytes": 2684864,
		"size": "2.56 mb"
	},
	"change": {
		"size_bytes": 1191560,
		"size": "1.14 mb",
		"freed_nodes": 129, //释放的节点数
		"allocated_nodes": 20028,//分配的节点数
		"details": [{
			"what": "Array",
			"size_bytes": 323720,
			"size": "316.13 kb",
			"+": 15,
			"-": 65
		}, {
			"-": 28
		}, {
			"what": "String",
			"size_bytes": 879424,
			"what": "Code",
			"size_bytes": -10944,
			"size": "-10.69 kb",
			"+": 8,
			"size": "858.81 kb",
			"+": 20001, //大量的string未被回收
			"-": 1
		}]
	}
}

大内存应用

  • 使用stream模块处理大文件，fs的createReadStream(),createWriteStream()
1
2
3
4
5
6
7
8
9
10
11
12
13
var reader = fs.createReadStream('in.txt');
var writer = fs.createWriteStream('out.txt');
reader.on('data', function(chunk) {
	writer.write(chunk);
});
reader.on('end', function() {
	writer.end();
});
//管道方法pipe()，封装了data事件和写入
var reader = fs.createReadStream('in.txt');
var writer = fs.createWriteStream('out.txt');
reader.pipe(writer);

在不需要进行字符串操作时，可以不借助v8，使用Buffer操作，这样不会受到v8的内存限制

Smaller icon