欢迎光临
我们一直在努力

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

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开始前调用。

参考链接:

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

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

https://segmentfault.com/a/1190000022317412

赞(0)
未经允许不得转载:ITyet » 强大的异步专家process.nextTick()
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址