nodejs buffer

发表于   |   分类于   |  

Buffer结构

  • 类似Array，为16进制的两位数，即占一个字节
  • js与c++结合的模块，内存由c++申请，js分配。因为v8垃圾回收影响性能
  • node启动时就加载，放在全局对象global
1
2
var buf = new Buffer(100);
console.log(buf.length); // => 100

如给buffer赋值数字，则范围在0-255,否则负数就加256,过大就减256

内存使用slab分配机制，动态内存管理，包含三种状态（full,partial,empty）。Node以8KB为界限区分Buffer是大对象还是小对象（Buffer.poolSize=8*1024），即8kb为slab单元大小，js以它为单元分配内存

分配小Buffer对象

  • 小于8kb

使用局部变量pool,让处于分配状态的slab单元指向它

1
2
3
4
5
6
var pool;
function allocPool() {
	pool = new SlowBuffer(Buffer.poolSize);
	pool.used = 0;
}

新建小buffer时，如果还没pool,就创建一个slab指向它，当前的buffer对象的parent指向slab

1
2
3
4
this.parent = pool; //当前的buffer对象的parent指向slab
this.offset = pool.used;//slab开始使用的位置
pool.used += this.length;//slab已使用量
if (pool.used & 7) pool.used = (pool.used + 8) & ~7;

此时slab状态为partial,在创建buffer时会判断次slab是否够用，如果不够，就构建新的slab,原来的slab剩余的空间浪费，如果不释放就占据8kb

分配大Buffer

直接分配一个SlowBuffer对象作为slab单元，并且独占

1
2
// Big buffer,just alloc one  SlowBuffer由c++定义,勿直接操作它
this.parent=new SlowBuffer(this.length);this.offset=0;

Buffer对象是js层面的，能被v8标记回收，但其内部parent指向SlowBuffer,由c++提供的Buffer,所以内存由c++提供，js只是使用它，对于小buffer的频繁操作，使用slab机制来先申请后分配，减少内存申请的系统调用，对于大buffe就直接用C++提供内存

Buffer转换

  • 支持的字符串编码 ASCII,UTF-8,UTF-16LE/UCS-2,Base64,Binary,Hex

字符串与Buffer的转换

字符串转buffer,使用构造函数new Buffer(str,[encoding]);默认UTF-8

一个Buffer对象可以存多种编码类型的字符串转码的值

1
buf.write(string, [offset], [length], [encoding])

buffer转字符串

1
buf.toString([encoding], [start], [end]) //encoding默认UTF-8,配合start和end实现局部转换

Buffer不支持的编码类型

  • 使用Buffer.isEncoding(encoding)判断

iconv 通过c++调用libiconv
iconv-lite使用纯js实现，但基于v8高性能，少了c++到js的转换，所以比C++实现好

1
2
var iconv = require("iconv-lite");var str = iconv.decode(buf,"win1251");
var buf = iconv.encode('Sample input string', 'win1251');

对无法转换的内容会降级处理，输出部分或者？

Buffer拼接

1
2
3
4
5
6
7
8
9
var fs = require('fs');
var rs = fs.createReadStream('test.md');
var data = '';
rs.on("data", function(chunk) {
	data += chunk; //等价于data = data.toString() + chunk.toString();此处对宽字节的中文可能造成乱码，即字节没读全就转码
});
rs.on("end", function() {
	console.log(data);
});

解决乱码问题

  • 在调用setEncoding()时，可读流对象在内部设置一个decoder对象

req.setEncoding(‘utf8’);

1
2
3
4
5
6
7
8
var StringDecoder = require('string_decoder').StringDecoder;
var decoder = new StringDecoder('utf8');
var buf1 = new Buffer([0xE5, 0xBA, 0x8A, 0xE5, 0x89, 0x8D, 0xE6, 0x98, 0x8E, 0xE6, 0x9C]);
console.log(decoder.write(buf1));
// => 床前明
var buf2 = new Buffer([0x88, 0xE5, 0x85, 0x89, 0xEF, 0xBC, 0x8C, 0xE7, 0x96, 0x91, 0xE6]);
console.log(decoder.write(buf2));
// =>月光，凝

StringDecoder在得到编码后，知道宽字节在utf-8下占3个字节，所以在处理末尾不全的字节时，会保留到第二次write().目前只能处理UTF-8、Base64和UCS-2/UTF-16LE

正确拼接Buffer

1
2
3
4
5
6
7
8
9
10
11
var chunks = [];
var size = 0;
res.on('data', function(chunk) {
	chunks.push(chunk);
	size += chunk.length;
});
res.on('end', function() {
	var buf = Buffer.concat(chunks, size);
	var str = iconv.decode(buf, 'utf8');
	console.log(str);
});

用数组来储存接收的所有Buffer片段并记录总长度，然后调用Buffer.concat()–>

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
Buffer.concat = function(list, length) {
	if (!Array.isArray(list)) {
		throw new Error('Usage: Buffer.concat(list, [length])');
	}
	if (list.length === 0) {
		return new Buffer(0);
	} else if (list.length === 1) {
		return list[0];
	}
	if (typeof length !== 'number') {
		length = 0;
		for (var i = 0; i < list.length; i++) {
			var buf = list[i];
			length += buf.length;
		}
	}
	var buffer = new Buffer(length);
	var pos = 0;
	for (var i = 0; i < list.length; i++) {
		var buf = list[i];
		buf.copy(buffer, pos);
		pos += buf.length;
	}
	return buffer;
};

Buffer与性能

Buffer广泛应用于文件I/O和网络I/O,尤其在网络传输，使用Buffer比直接使用字符串要性能要高很多。在web开发中对于静态内容可以预先转成buffer,在不需要改变内容时，只读取buffer,不做转换

文件读取

fs.createReadStream()先在内存中准备一段buffer,然后在fs.read()读取时逐步将磁盘中的字节复制到buffer,读完一次就用slice()从buffer取出部分作为小buffer通过data事件传给调用方。Buffer用完会重新分配

1
2
3
4
5
6
7
8
9
fs.createReadStream(path, opts)
//参数
{
	flags: 'r',
	encoding: null,
	fd: null,
	mode: 0666,
	highWaterMark: 64 * 1024 // 每次读取的长度
}

重新分配

1
2
3
4
5
6
7
8
9
10
11
12
var pool;//常驻内存
function allocNewPool(poolSize) {
	pool = new Buffer(poolSize);
	pool.used = 0;
}
//当pool剩余数量小于128(kMinPoolSpace)字节时，会重新分配
if (!pool || pool.length - pool.used < kMinPoolSpace) { 
// discard the old pool
	pool = null;
	allocNewPool(this._readableState.highWaterMark);
}

highWaterMark的大小对性能的影响有：buffer内存的分配和使用、系统调用次数;

  • 文件流读取基于buffer,buffer基于slowbuffer，文件小于8kb可能造成slab浪费
  • fs.createReadStream()内部使用fs.read()，会引起系统对磁盘的调用，highWaterMark的大小决定调用次数和data事件次数

Smaller icon