[date: 2018-08-14 16:55] [visits: 9]

使用子进程方式避免sharp rss占用过大

前些日子写了一篇文章-记一次内存泄漏处理,曲折过后发现并不是内存泄漏问题,而是rss占用过大,这篇文章讲述自己解决这个rss占用过大问题的一种方式:子进程调用。

前情回顾

应用中有一个服务端合成海报图片的功能,这个功能借助第三方库sharp实现,在应用运行一段时间后发现内存占用在500M以上,最初当成内存泄漏定位并在mac下重现了内存泄漏现象,但剧情反转,同样的代码在linux下并没有出现内存泄漏现象,随后经过一系列验证发现的确是rss占用过大的问题,最起码在linux下是。

详细内容可以参考记一次内存泄漏处理这篇文章,或者这个issue

tips

rss是resident set size的缩写,即实际使用物理内存,rss占用过大与内存泄漏的区别在于前者是内存需求后者则是BUG,如果机器内存不够两者都会导致OOM(Out Of Memory)异常最终系统崩溃

子进程

进程是操作系统进行资源分配和调度的基本单位,从一个运行中的进程(父进程)中创建一个新的进程,这个新的进程就称为子进程,在Node.js中创建子进程主要依靠child_process模块,但这个模块提供了多种创建的方式,相互之间也有一些差异,下面做一些简单的说明和对比。

child_process.spawn

spawn(command[, args][, options])

执行command命令,args是命令行参数数组,options则是关于子进程行为控制的选项,常用而且重要的有detached与stdio。

detached

分离,意思是子进程是否从父进程中分离出来,分离出来的子进程在父进程退出后仍可运行,未分离的子进程则受到linux下进程组等概念约束会随主进程一起退出。

曾经在做一个测试环境根据git webhook通过子进程方式自动部署功能时踩过这个坑,由于没有设置detached为true,当子进程通过pm2 reload xxx时有概率先重启自己的父进程导致自己被杀掉了,从而导致其他进程没有重启。

stdio

stdio是standard input output的简称,标准输入输出,此处主要指如何处理子进程的stdin、stdout与stderr,主要有三种方式:

pipe可以为子进程创建管道,灵活的处理子进程输入输出相关逻辑,这是默认行为

ignore会忽视子进程的输入输出,类似在shell中执行命令没有输入并把输出重定向到/dev/null

inherit是共享父进程的标准输入输出,如父进程的console.log是输出在屏幕上,则子进程中的输出同样会打印在屏幕上

child_process.exec

exec(command[, options][, callback])

在shell中执行command命令,callback函数会返回err、stdout与stderr,options与spawn类似也有不同。

首先是command的区别,在spawn中命令行参数通过args数组传递,在exec中则是与command拼接在一起,拿列出/root目录下的文件举例:

const cp = require('child_process');

// spawn
cp.spawn('ls', ['/root'], {});

// exec
cp.exec('ls /root', {}, (err, stdout, stderr) => {});

其次是stdio的区别,exec中options参数不支持传stdio,也就无法对子进程进行输入,但输出可以通过callback获取,不过需要注意options.maxBuffer参数会限制输出的最大长度,默认大小200 * 1024。

从设计上看,exec比spawn更适合执行一些持续过程短暂的命令,苦于未找到exec如何支持stdin,后面还是选择了spawn方式。

child_process.execFile

execFile(file[, args][, options][, callback])

与exec基本一样,区别是直接运行执行文件而不是通过shell,可以带来些许性能优势。

child_process.fork

fork(modulePath[, args][, options])

fork是spawn的一个特例,专门用于生成新的Node.js进程,modulePath是一个Node.js可执行文件的路径,这种方式会在父子进程间建立一个额外的通信通道,这对于需要频繁沟通的父子进程来说,是一个非常有帮助的特性。

除fork外,另外几个方法也都有对应的同步版本,就不再进行说明,如果对child_process不熟悉的童鞋强烈建议看看官方文档,然后写代码熟悉一下,没有一两个小时的思考和琢磨,弄不太明白。

实现思路

由于sharp合成图片这个功能会导致应用多占用300+M内存(长期累积,sharp内部不及时释放),所以就设想把该功能用子进程调用的方式实现,每次调用子进程合成图片,随后子进程被销毁其对应的内存也就释放了。

子进程依旧使用Node.js脚本,输入需要合成的图片信息,返回合成后的图片,这里选择使用spawn方法创建子进程,图片以及信息输入采用offset + buffer的方式。

使用sharp合成的原理是有一张background原图,然后叠加其他图片如img1:{top, left}img2:{top, left}等,由于所叠加的图片是变量,因此需要由应用(父进程)传递给子进程,普通信息传递一般选择json,但img的内容是buffer导致直接使用json不可行,所以这里选择采用offset + buffer的方式:

通过命令行参数传递offset、通过spawn的标准输入传递一个完整buffer,在子进程内部根据offset按规则解析buffer,还原所有的信息

假设需要在background上合成img1(size: 100, top: 0, left: 0)与img2(size: 50, top: 100, left: 100),我们先构建一个原始的buffer数组:

buffer = [buffer(background), buffer(JSON.stringify([100, 0, 0])), buffer(img1), buffer(JSON.stringify([50, 100, 100])), buffer(img2)]

随后根据数组中每一个buffer长度得到一个offset数组:

offset = [12738, 281, 18282, 281, 28329] // 瞎填的

最终传递offset.join('|')Buffer.concat(buffer),至于子进程内部如何还原参考后面的代码。这里也可以选择将图片内容base64编码后使用json方式传递,但offset + buffer的方式理论上更高效。

简化实现代码

为了减少文章长度,下面是经过简化的代码且未经过测试,主要用于传达一些实现细节。

应用内逻辑:

const C = require('../constant');
const cp = require('child_process');
const nPath = require('path');
const _ = require('lodash');
const Promise = require('bluebird');

// 等待被叠加的图片数组,如用户头像,商品信息等等
let images = []; 

let buffer = _.flatten(_.map(images, item => {
    // 子进程可以根据name做一些其他处理,如制作圆形图片,白色边框等等
    // offset是图片合成时在背景图上的位置 
    return [Buffer.from(JSON.stringify(_.pick(item, ['name', 'offset'])), 'utf8'), item.buffer];
}));

buffer.unshift(C.SHARE_BUFFER); // 背景图

let offset = _.map(buffer, item => item.length);

return spawn('node', [nPath.join(__dirname, 'sharpPost.js'), offset.join('|')], {
    stdin: Buffer.concat(buffer)
}).then(ret => {
    if (!_.isEmpty(ret.stderr)) {
        return Promise.reject(new Error(ret.stderr.toString()));
    }

    return ret.stdout; // 合成后的图片
});

// spawn的二次包装
function spawn(command, args, options = {}) {
    return new Promise((resolve, reject) => {
        let stdout = [];
        let stderr = [];

        let fork = cp.spawn(command, args, _.assign({
            detached: true
        }, options));

        let timeout = setTimeout(() => {
            if (fork.connected) {
                fork.stdin.pause();
                fork.kill();
            }

            reject(new Error('resulted in a timeout.'));
        }, 1000 * 60 * 5); // five minutes


        fork.stdin.once('error', reject);
        if (options.stdin) {
            let input = new stream.PassThrough();
            input.end(options.stdin);
            input.pipe(fork.stdin);
        }
        else {
            fork.stdin.end(null);
        }

        fork.stdout.on('data', data => stdout.push(data));
        fork.stderr.on('data', data => stderr.push(data));

        fork.on('error', reject);
        fork.on('close', (code, signal) => {
            clearTimeout(timeout);

            if (code !== 0 || signal !== null) {
                let err = new Error('command failed.');
                err.code = code;
                err.signal = signal;

                return reject(err);
            }

            return resolve({
                stdout: Buffer.concat(stdout),
                stderr: Buffer.concat(stderr)
            });
        });
    });
}

脚本文件sharpPost.js:

const Promise = require('bluebird');
const sharp = require('sharp');
sharp.cache(false);

let offset = process.argv[2].split('|').map(item => Number(item));
let buffer = [];

process.stdin.on('data', chunk => {
    buffer.push(chunk);
});

process.stdin.on('end', () => {
    buffer = Buffer.concat(buffer);

    let background = buffer.slice(0, offset[0]);

    let items = [];
    let current = offset[0];
    for (let i = 1; i < offset.length; i = i + 2) {
        let item = JSON.parse(buffer.slice(current, current + offset[i]).toString('utf8'));

        item.buffer = buffer.slice(current + offset[i], current + offset[i] + offset[i + 1]);

        items.push(item);
        current += offset[i] + offset[i + 1];
    }
    
    return Promise.reduce(ret, (buffer, item) => {
        return sharp(buffer)
            .overlayWith(item.buffer, {
                top: item.offset[0],
                left: item.offset[1]
            })
            .toBuffer();
    }, background).then(ret => {
        return sharp(ret).jpeg().toBuffer();
    }).then(ret => {
        process.stdout.write(ret);

        return {};
    });
}

总结

sharp合成图片的代码没有从应用中独立出来时,线上应用启动10小时后内存占用稳定在500M左右,而采用子进程调用的方式后应用内存大小稳定在200M左右,效果显著。

这个图片合成功能本身具有一些特性:

因为上诉特性,所以选择子进程方式实现是可能的,而如果是一个高频、要求低延迟的接口,这种方式是万万不行的,另外这种接口还需要做一些防护措施,避免轻易遭受恶意攻击的负面影响。