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_semispace_size_（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,所以赋值更好)

闭包

• 外部作用域访问内部作用域的方法，得益于高阶函数特性

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导出(闭包),作用域不会释放，常驻老生代。要注意内存泄漏

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

推荐使用进程外缓存，<a href='https://github.com/mranney/node_redis' target='_blank'>Redis</a>、<a href='https://github.com/3rd-Eden/node-memcached' target='_blank'>Memcached</a>

队列状态

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

内存泄漏排查

node-heapdump

1. 安装 npm install heapdump
2. 在开头引入 var heapdump = require('heapdump');
3. 发送命令kill -USR2 <pid>，heapdump会抓拍一份堆内存快照，文件为heapdump-<sec>.<usec>.heapsnapshot格式，是json文件

node-memwatch

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事件，该事件会传递内存的统计信息

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事件

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的堆上

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

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的内存限制