强大的异步专家process.nextTick()

2020-04-09  本文已影响0人  趁你还年轻233

在阅读mqtt.js源码的时候，遇到一段很令人疑惑的代码。
nextTickWork中调用process.nextTick(work)，其中函数work又调用了nextTickWork。
这怎么这想递归呢？又有点像死循环？
到底是怎么回事啊，下面我们来系统性学习一下process.nextTick()。

writable._write = function (buf, enc, done) {
    completeParse = done
    parser.parse(buf)
    work() // 开始nextTick
}
function work () {
  var packet = packets.shift()
  if (packet) {
    that._handlePacket(packet, nextTickWork) // 注意这里
  } else {
    var done = completeParse
    completeParse = null
    if (done) done()
  }
}
function nextTickWork () {
  if (packets.length) {
    process.nextTick(work) // 注意这里
  } else {
    var done = completeParse
    completeParse = null
    done()
  }
}

初识process.nextTick()

语法（callback和可选args）

process.nextTick(callback[, ...args])

process.nextTick()知识点

process.nextTick()使用示例

最简单的例子
console.log('start');
process.nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// start
// scheduled
// nextTick callback
process.nextTick()可用于控制代码执行顺序

process.nextTick()可用于赋予用户一种能力，去保证方法在对象完成constructor后但是在I/O发生前调用。

function MyThing(options) {
  this.setupOptions(options);
  process.nextTick(() => {
    this.startDoingStuff();
  });
}
const thing = new MyThing();
thing.getReadyForStuff(); // thing.startDoingStuff() 在准备好之后再调用，而不是在初始化就调用
API要么100%同步要么100%异步时很重要的

API要么100%同步要么100%异步是很重要的，可以通过process.nextTick()去使得一个API完全异步化达到这种保证。

// 可能是同步，可能是异步的API
function maybeSync(arg, cb) {
  if (arg) {
    cb();
    return;
  }
  fs.stat('file', cb);
}

// maybeTrue可能为false可能为true，所以foo(),bar()的执行顺序无法保证。
const maybeTrue = Math.random() > 0.5;
maybeSync(maybeTrue, () => {
  foo();
});
bar();

如何使得API完全是一个async的API呢？或者说如何保证foo()在bar()之后调用呢？
通过process.nextTick()完全异步化。

// 完全是异步的API
function definitelyAsync(arg, cb) {
  if (arg) {
    process.nextTick(cb);
    return;
  }
  fs.stat('file', cb);
}

如何理解process.nextTick()

你也许会发现process.nextTick()不会在代码中出现，即使它是异步API的一部分。这是为什么呢？因为process.nextTick()不是event loop的技术部分。取而代之的是，nextTickQueue会在当前的操作完成后执行，不考虑event loop的当前阶段。在这里，operation的定义是指从底层的C/C++处理程序到处理需要执行的JavaScript的转换。

回过头来看我们的程序，任何阶段你调用process.nextTick()，所有传递进process.nextTick()的callback会在event loop继续前完成解析。这会造成一些糟糕的情况，通过建立一个递归的process.nextTick()调用，它允许你“starve”你的I/O。，这样可以使得event loop不到达poll阶段。

为什么说process.nextTick()是更加强大的异步专家？

process.nextTick()比setTimeout()更精准的延迟调用

为什么说“process.nextTick()比setTimeout()更精准的延迟调用”呢？
不要着急，带着疑问去看下文即可。看懂就能找到答案。

为什么Node.js要设计这种递归的process.nextTick()呢 ？这是因为Node.js的设计哲学的一部分是API必须是async的，即使它没有必要。 看下下面的例子：

function apiCall(arg, callback) {
    if(typeof arg !== 'string'){
        return process.nextTick(callback, new TypeError('argument should be string'));
    }
}

代码片段做了argument的检查，如果它不是string类型的话，它会将一个error传递进callback中。这个API最近进行了更新，允许将参数传递到process.nextTick()，从而允许在callback之后传递的任何参数作为回调的参数进行传递，这样就不用嵌套函数了。

我们现在做的是将一个error传递到user，但是必须在我们允许执行的代码执行完之后。通过使用process.nextTick()，我们可以保证apiCall总是在用户代码的其余部分和允许事件循环继续之前运行它的callback。为了实现这一点，JS call stack可以被展开，然后immediately执行提供的回调，从而允许一个人递归调用process.nextTick()而不至于抛出RangeError: Maximum call stack size exceeded from v8.）

一句话概括的话就是：process.nextTick()可以保证我们要执行的代码会正常执行，最后再抛出这个error。这个操作是setTimeout()无法做到的，因为我们并不知道执行那些代码需要多长时间。

是怎么做到process.nextTick(callback)比setTimeout()更严格的延迟调用的呢？
process.nextTick(callback)可以保证在这一次事件循环的call stack 解除（unwound）后，在下一次事件循环前，调用callback。

可以把原因再讲得详细一点吗？

process.nextTick()会在这一次event loop的call stack清空后（下一次event loop开始前）再调用callback。而setTimeout()是并不知道什么时候call stack清空的。我们setTimeout(cb, 1000)，可能1s后，由于种种原因call 栈中还留存了几个函数没有调用，调大到10秒又很不合适，因为它可能1.1秒就执行完了。

相信有一定开发经验的同学一看就懂，一看就知道process.nextTick()的强大了。
心里默念：“终于不用调坑爹的setTimeout延迟参数了！”

强大的process.nextTick()解决的实际问题

这个哲学会导致一些潜在问题。下面来看下这段代码：

let bar;
//  它是异步，但是同步调用callback
function someAsyncApiCall(callback) { callback(); }
// callback在someAsyncApiCall完成前调用
someAsyncApiCall(() => {
  // 因为someAsyncApiCall还没有完成，bar还未赋值
  console.log('bar', bar); // undefined
});
bar = 1;

用户定义了有一个异步签名的someAsyncApiCall()，但是它实际上同步执行了。当someAsyncApiCall()调用的时候，内部的callback在异步操作还没完成前就调用了，callback尝试获得bar的引用，但是作用域内是没有这个变量的，因为script还没有执行到bar = 1这一步。

有什么办法可以保证在赋值之后再调用这个函数呢？

通过将callback传递进process.nextTick()，script可以成功执行，并且可以访问到所有变量和函数等等，并且在callback调用之前已经初始化好。 它拥有允许不允许事件循环继续的优点。对于用户在event loop想要继续运行之前alert一个error是很有用的。

下面是通过process.nextTick()改进的上面的代码：

let bar;
function someAsyncApiCall(callback) {
    process.nextTick(callback);
}
someAsyncApiCall(() => {
  console.log('bar', bar); // 1
});
bar = 1;

还有一个真实世界的例子：

const server = net.createServer(() => {}).listen(8080);
server.on('listening', () => {});

当我们传递一个端口号进去时，端口号会被立刻绑定。所以'listening' callback可以被立即调用。问题是.on('listening');这个callback可能还没设置呢？这要怎么办?

为了做到在精准无误的监听到listen的动作，将对‘listening’事件的监听操作，队列到nextTick()，从而可以允许代码完全运行完毕。 这可以使得用户设置任何他们想要的事件。

为什么要用process.nextTick()？

允许用户处理error，清除不需要的资源，或者在事件循环前再次尝试请求

这里有一个匹配用户期望的例子。

const server = net.createServer();
server.on('connection', (conn) => { });

server.listen(8080);
server.on('listening', () => { });

listen()在event.loop循环的开始运行，但是listening callback被放置在setImmediate()中。除非传入hostname，否则立即绑定端口。event loop在处理的时候，它必须在poll阶段，这也就是意味着没有机会接收到连接，从而允许在侦听listen事件前触发connection事件。

有时确保callback在call stack unwound（解除）后，event loop继续循环前 调用

再来看一个例子：
运行一个继承了EventEmitter的function constructor，它想在constructor内部发出一个'event'事件。

const EventEmitter = require('events');
const util = require('util');

function MyEmitter() {
  EventEmitter.call(this);
  this.emit('event');
}
util.inherits(MyEmitter, EventEmitter);
const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('an event occurred!'); // nothing happens
});

无法在constructor内理解emit一个event，因为script不会运行到用户监听event响应callback的位置。所以在constructor内部，可以使用process.nextTick设置一个callback在constructor完成之后emit这个event，所以最终的代码如下：

const EventEmitter = require('events');
const util = require('util');

function MyEmitter() {
  EventEmitter.call(this);
  // 一旦分配了handler处理程序，就使用process.nextTick()发出这个事件
  process.nextTick(() => {
    this.emit('event');
  });
}
util.inherits(MyEmitter, EventEmitter);
const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('an event occurred!'); // an event occurred!'
});

回顾一下

回过头来看下mqtt.js用于接收消息的message event源码中的process.nextTick()

process.nextTick()确保work函数准确在这一次call stack清空后，下一次event loop开始前调用。

writable._write = function (buf, enc, done) {
    completeParse = done
    parser.parse(buf)
    work() // 开始nextTick
}
function work () {
  var packet = packets.shift()
  if (packet) {
    that._handlePacket(packet, nextTickWork) // 注意这里
  } else {
    // 中止process.nextTick()的递归
    var done = completeParse
    completeParse = null
    if (done) done()
  }
}
function nextTickWork () {
  if (packets.length) {
    process.nextTick(work) // 注意这里
  } else {
   // 中止process.nextTick()的递归
    var done = completeParse
    completeParse = null
    done()
  }
}

通过对process.nextTick()的学习以及对源码的理解，我们得出：
流写入本地执行work()，若接收到有效的数据包，开始process.nextTick()递归。

function nextTickWork () {
  if (packets.length) {
    work() // 注意这里
  }
}

会造成当前的event loop永远不会中止，一直处于阻塞状态，造成一个无限循环。
正是因为有了process.nextTick()，才能确保work函数准确在这一次call stack清空后，下一次event loop开始前调用。

参考链接：

期待和大家交流，共同进步，欢迎大家加入我创建的与前端开发密切相关的技术讨论小组：

image

努力成为优秀前端工程师！

上一篇下一篇

猜你喜欢

热点阅读