Node.js源码解析-Buffer的8k池实现
欢迎来我的博客阅读：《Node.js源码解析-Buffer的8k池实现》
在 Node.js 中，对于大文件一般是以 Buffer 形式存储，相比于字符串，Buffer 可以免去 decode / encode 过程，节省 CPU 成本
说到 Buffer 就不得不提到 Buffer 的 8k 池，那么，下面就让我们来看看 8k 池是如何实现的吧
8k池实现
在 Node.js v8.4.0 中，可以通过以下方法来获取一个 Buffer 实例：
-
new Buffer()( 不推荐 ) Buffer.from()Buffer.alloc()Buffer.allocUnsafe()Buffer.allocUnsafeSlow()
从命名上来看，Buffer.allocUnsafe() 和 Buffer.allocUnsafeSlow() 都是不安全的，有泄漏内存中敏感信息的危险
unsafe 的问题放到后面说，先看看如何获取一个 Buffer 实例
从图中可以看出，只有 allocate() 和 fromString() 两个函数直接与8k池相关
// lib/buffer.js
function allocate(size) {
if (size <= 0) {
return new FastBuffer();
}
if (size < (Buffer.poolSize >>> 1)) { // < 4k
if (size > (poolSize - poolOffset)) // 大于剩余容量
createPool();
var b = new FastBuffer(allocPool, poolOffset, size);
poolOffset += size;
alignPool();
return b;
} else { // > 4k
return createUnsafeBuffer(size);
}
}
function fromString(string, encoding) {
// ...
if (length >= (Buffer.poolSize >>> 1)) // > 4k
return binding.createFromString(string, encoding);
if (length > (poolSize - poolOffset)) // 大于剩余容量
createPool();
var b = new FastBuffer(allocPool, poolOffset, length);
const actual = b.write(string, encoding);
if (actual !== length) { // byteLength() 可能会估计错误，尽管可能性很小
b = new FastBuffer(allocPool, poolOffset, actual);
}
poolOffset += actual;
alignPool();
return b;
}
allocate() 和 fromString() 都是分为大于 4k 和小于 4k 两种情况来处理
小于 4k 时，先检查8k池的剩余容量，如果大于剩余容量则直接创建一个新的8k池，然后修正 poolOffset，最后调用 alignPool()
// lib/buffer.js
Buffer.poolSize = 8 * 1024;
var poolSize, poolOffset, allocPool;
function createUnsafeArrayBuffer(size) {
// ...
return new ArrayBuffer(size);
// ...
}
function createPool() {
poolSize = Buffer.poolSize; // 8k
allocPool = createUnsafeArrayBuffer(poolSize);
poolOffset = 0;
}
createPool();
function alignPool() {
if (poolOffset & 0x7) { // 进行校准，只能为 8 的倍数
poolOffset |= 0x7; // xxx111
poolOffset++; // xx(x+1)000
}
}
通过调用 alignPool() 来校准 poolOffset，poolOffset 只能为 8 的倍数，换句话说，每次至少使用 8 个字节内存
8k池容量不够时，调用 createPool()，创建一个新的8k池
createPool() 内部调用 createUnsafeArrayBuffer() 来获取一个对应大小的 ArrayBuffer 实例
关于 ArrayBuffer，这里引用 MDN 的介绍：
The ArrayBuffer object is used to represent a generic, fixed-length raw binary data buffer
因为 ArrayBuffer 是 raw binary data，所以它是不安全的，存在泄漏内存中敏感信息的危险
Why Unsafe ?
从图中我们知道，一共有 4 种方法来获得一个 Buffer 实例，它们之中，有的是 unsafe 的，有的不是
new Buffer()依赖Buffer.from()和Buffer.alloc()不算一种
下面让我们来看看为什么有的是 unsafe 的
// lib/buffer.js
// safe
Buffer.from = function(value, encodingOrOffset, length) {
if (typeof value === 'string')
return fromString(value, encodingOrOffset); // safe
if (isAnyArrayBuffer(value))
return fromArrayBuffer(value, encodingOrOffset, length); // safe
var b = fromObject(value); // safe
// ...
};
function fromString(string, encoding) {
// ...
var b = new FastBuffer(allocPool, poolOffset, length);
const actual = b.write(string, encoding);
// ...
}
function fromArrayBuffer(obj, byteOffset, length) {
// ...
return new FastBuffer(obj, byteOffset, length);
}
function fromObject(obj) {
if (isUint8Array(obj)) {
const b = allocate(obj.length);
// ...
binding.copy(obj, b, 0, 0, obj.length);
}
if (obj != null) {
// ...
return fromArrayLike(obj);
// ...
}
}
function fromArrayLike(obj) {
// ...
const b = allocate(length);
for (var i = 0; i < length; i++)
b[i] = obj[i];
return b;
}
// unsafe
Buffer.allocUnsafe = function(size) {
return allocate(size);
};
// unsafe
Buffer.allocUnsafeSlow = function(size) {
return createUnsafeBuffer(size);
};
function createUnsafeBuffer(size) {
return new FastBuffer(createUnsafeArrayBuffer(size));
}
// safe
Buffer.alloc = function(size, fill, encoding) {
assertSize(size);
if (size > 0 && fill !== undefined) {
// ...
return createUnsafeBuffer(size).fill(fill, encoding);
}
return new FastBuffer(size);
};
可以看出:
-
Buffer.from()和Buffer.alloc(): 取到原始 buffer 后，对原始数据进行了替换，所以它们是 safe 的 -
Buffer.allocUnsafe()和Buffer.allocUnsafeSlow(): 直接使用原始 buffer，所以它们是 unsafe 的
End
-
new Buffer(): 依赖Buffer.from()和Buffer.alloc() -
Buffer.from()- ArrayBuffer: 直接使用 ArrayBuffer 创建 FastBuffer
- String: 小于 4k 使用8k池，大于 4k 调用
binding.createFromString() - Object: 小于 4k 使用8k池，大于 4k 调用
createUnsafeBuffer()
-
Buffer.alloc(): 需要 fill buffer，用给定字符填充，否则用 0 填充 -
Buffer.allocUnsafe(): 小于 4k 使用8k池，大于 4k 调用createUnsafeBuffer() -
Buffer.allocUnsafeSlow(): 调用createUnsafeBuffer()
参考：
