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

头像
趁你还年轻
    阅读 7 分钟
    4

    processNextTick.jpg

    在阅读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()知识点

      • process.nextTick()使用示例

        • 最简单的例子
        • process.nextTick()可用于控制代码执行顺序
        • process.nextTick()可完全异步化API
    • 如何理解process.nextTick()？

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

      • process.nextTick()比setTimeout()更严格的延迟调用
      • process.nextTick()解决的实际问题

    • 为什么要用process.nextTick()？

      • 允许用户处理error，清除不需要的资源，或者在事件循环前再次尝试请求
      • 有时确保callback在call stack unwound（解除）后，event loop继续循环前 调用
    • 回顾一下

    初识process.nextTick()

    语法（callback和可选args）

    process.nextTick(callback[, ...args])
    • callback 回调函数
    • args 调用callback时额外传的参数

    process.nextTick()知识点

    • process.nextTick()会将callback添加到”next tick queue“
    • ”next tick queue“会在当前JavaScript stack执行完成后，下一次event loop开始执行前按照FIFO出队
    • 如果递归调用process.nextTick()可能会导致一个无限循环，需要去适时终止递归。
    • process.nextTick()可用于控制代码执行顺序。保证方法在对象完成constructor后但是在I/O发生前调用。
    • process.nextTick()可完全异步化API。API要么100%同步要么100%异步是很重要的，可以通过process.nextTick()去达到这种保证

    process.nextTick()使用示例

    • 最简单的例子

    • process.nextTick()对于API的开发很重要

      最简单的例子
      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，清除不需要的资源，或者在事件循环前再次尝试请求
    • 有时确保callback在call stack unwound（解除）后，event loop继续循环前 调用

    允许用户处理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()递归。

    • 开始nextTick的条件：if(packet)/if (packets.length) 也就是说有接收到websocket包时开始。
    • 递归nextTick的过程：work()->nextTickWork()->process.nextTick(work)。
    • 结束nextTick的条件：packet为空或者packets为空，通过completeParse=null，done()结束递归。

    • 如果对work不加process.nextTick会怎样？

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

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

    参考链接：

    期待和大家交流，共同进步：

    • 微信公众号： 大大大前端 / excellent_developers
    • 前端问答互助星球：t.zsxq.com/yBA2Biq

    努力成为优秀前端工程师！
    前端node.jsjavascript
    趁你还年轻
    4.1k 声望4.1k 粉丝
    « 上一篇
    物联网宠儿mqtt.js那些事儿
    下一篇 »
    发现算法之美-时间复杂度

    引用和评论

    被 3 篇内容引用
    推荐阅读
    头像
    浅谈业务中台前端设计

    趁你还年轻赞 2阅读 2.2k

    头像
    网页设计的垂直居中

    寒青赞 41阅读 5.2k评论 3

    头像
    CSS团队协作规范

    寒青赞 38阅读 7.3k

    头像
    前端如何入门 Go 语言

    robin赞 28阅读 8.3k评论 9

    头像
    100个React最佳实践小技巧

    夕水赞 25阅读 6.5k评论 4

    头像
    前端开发工具

    寒青赞 19阅读 5.2k

    头像
    开发插件集合

    寒青赞 14阅读 3.5k

    0 条评论
    得票最新