nodejs事件和事件循环简介

简介

熟悉javascript的朋友应该都使用过事件，好比鼠标的移动，鼠标的点击，键盘的输入等等。咱们在javascript中监听这些事件，从而触发相应的处理。

一样的nodejs中也有事件，而且还有一个专门的events模块来进行专门的处理。

同时事件和事件循环也是nodejs构建异步IO的很是重要的概念。

今天咱们来详细了解一下。

事件

nodejs为事件提供了一个专门的模块：lib/events.js。

还记得咱们在讲使用nodejs构建web服务器吗？

const server = http.createServer((req, res) => {
  res.statusCode = 200
  res.setHeader('Content-Type', 'text/plain')
  res.end('welcome to www.flydean.com\n')
})

这里，每一个请求都会触发request事件。

nodejs的核心API是基于异步事件驱动来进行架构的，因此nodejs中有很是多的事件。

好比：net.Server 会在每次有新链接时触发事件，fs.ReadStream 会在打开文件时触发事件，stream会在数据可读时触发事件。

咱们看一下怎么来构建一个nodejs的事件：

const EventEmitter = require('events')
const eventEmitter = new EventEmitter()

events经常使用的方法有两个，分别是on和emit。

on用来监听事件，emit用来触发事件。

eventEmitter.on('fire', () => {
  console.log('开火')
})

eventEmitter.emit('fire')

emit还能够带参数，咱们看下一个参数的状况：

eventEmitter.on('fire', who => {
  console.log(`开火 ${who}`)
})

eventEmitter.emit('fire', '美帝')

再看看两个参数的状况：

eventEmitter.on('fire', (who, when) => {
  console.log(`开火 ${who} ${when}`)
})

eventEmitter.emit('fire', '川建国'，'now')

默认状况下，EventEmitter以注册的顺序同步地调用全部监听器。这样能够确保事件的正确排序，并有助于避免竞态条件和逻辑错误。

若是须要异步执行，则可使用setImmediate() 或者 process.nextTick()来切换到异步执行模式。

eventEmitter.on('fire', (who, when) => {
    setImmediate(() => {
      console.log(`开火 ${who} ${when}`);
  });
})

eventEmitter.emit('fire', '川建国'，'now')

除此以外，events还支持其余几个方法：

once(): 添加单次监听器

removeListener() / off(): 从事件中移除事件监听器

removeAllListeners(): 移除事件的全部监听器

事件循环

咱们知道nodejs的代码是运行在单线程环境中的，每次只会去处理一件事情。

这一种处理方式，避免了多线程环境的数据同步的问题，大大的提高了处理效率。

所谓事件循环，就是指处理器在一个程序周期中，处理完这个周期的事件以后，会进入下一个事件周期，处理下一个事件周期的事情，这样一个周期一个周期的循环。

事件循环的阻塞

若是咱们在事件处理过程当中，某个事件的处理发生了阻塞，则会影响其余的事件的执行，因此咱们能够看到在JS中，几乎全部的IO都是非阻塞的。这也是为何javascript中有这么多回调的缘由。

事件循环举例

咱们看一个简单的事件循环的例子：

const action2 = () => console.log('action2')

const action3 = () => console.log('action3')

const action1 = () => {
    console.log('action1')
    action2()
    action3()
}

action1()

上面的代码输出：

action1
action2
action3

栈和消息队列

咱们知道函数间的调用是经过栈来实现的，上面的例子中，咱们的调用顺序也是经过栈来实现的。

但并非函数中全部的方法都会入栈，还有一些方法会被放入消息队列。

咱们再举一个例子：

const action2 = () => console.log('action2')

const action3 = () => console.log('action3')

const action1 = () => {
    console.log('action1')
    setTimeout(action2, 0)
    action3()
}

action1()

上面的代码运行结果：

action1
action3
action2

结果不同了。这是由于settimeout触发了定时器，当定时器到期的时候，回调函数会被放入消息队列中等待被处理，而不是放入栈中。

事件循环会优先处理栈中的事件，只有栈中没有任何数据的时候，才会去转而消费消息队列中的事件。

虽然上面例子中setTimeout的timeout时间是0，可是仍是要等到action3执行完毕才能执行。

注意，setTimeout中的timeout并非在当前线程进行等待的，它是由浏览器或者其余JS执行环境来调用的。

做业队列和promise

ES6中的Promise引入了做业队列的概念，使用做业队列将会尽快地执行异步函数的结果，而不是放在调用堆栈的末尾。

举个例子：

const action2 = () => console.log('action2')

const action3 = () => console.log('action3')

const action1 = () => {
    console.log('action1')
    setTimeout(action2, 0)
    new Promise((resolve, reject) =>
        resolve('应该在action3以后、action2以前')
    ).then(resolve => console.log(resolve))
    action3()
}

action1()

输出结果：

action1
action3
应该在action3以后、action2以前
action2

这是由于，在当前函数结束以前 resolve 的 Promise 会在当前函数以后被当即执行。

也就是说先执行栈，再执行做业队列，最后执行消息队列。

process.nextTick()

先给你们一个定义叫作tick，一个tick就是指一个事件周期。而process.nextTick()就是指在下一个事件循环tick开始以前，调用这个函数：

process.nextTick(() => {
  console.log('i am the next tick');
})

因此nextTick必定要比消息队列的setTimeout要快。

setImmediate()

nodejs提供了一个setImmediate方法，来尽快的执行代码。

setImmediate(() => {
  console.log('I am immediate!');
})

setImmediate中的函数会在事件循环的下一个迭代中执行。

setImmediate() 和 setTimeout(() => {}, 0)的功能基本上是相似的。它们都会在事件循环的下一个迭代中运行。

setInterval()

若是想要定时执行某些回调函数，则须要用到setInterval。

setInterval(() => {
  console.log('每隔2秒执行一次');
}, 2000)

要清除上面的定时任务，可使用clearInterval：

const id = setInterval(() => {
  console.log('每隔2秒执行一次');
}, 2000)

clearInterval(id)

注意，setInterval是每隔n毫秒启动一个函数，无论该函数是否执行完毕。

若是一个函数执行时间太长，就会致使下一个函数同时执行的状况，怎么解决这个问题呢？

咱们能够考虑在回调函数内部再次调用setTimeout，这样造成递归的setTimeout调用：

const myFunction = () => {
  console.log('作完后，隔2s再次执行！');

  setTimeout(myFunction, 2000)
}

setTimeout(myFunction, 2000)

本文做者：flydean程序那些事

本文连接：http://www.flydean.com/nodejs-event/

本文来源：flydean的博客

欢迎关注个人公众号:「程序那些事」最通俗的解读，最深入的干货，最简洁的教程，众多你不知道的小技巧等你来发现！